Dr.-Ing. Andreas Daasch

Senior Software Developer & Architect
Embedded, Robotics & Local AI

I design system architectures and implement them myself — more code, fewer slides. For almost 20 years I have been building software for embedded systems, robotics and mechatronic products. Since 2023 I also build and operate local AI infrastructure: on-premise LLM inference, GPU servers and agent tooling — GDPR-compliant and without cloud lock-in.

  • 19 years of software engineering
  • Doctorate in control engineering
  • Freelancing since 2020
  • Munich · remote and on-site
  • German · English

Get in touch

Portrait photo of Dr.-Ing. Andreas Daasch

Services

Architecture & implementation from one hand

System architecture that I implement myself — from requirements engineering and interface design through to the tested system. Whether it is a new development or a system that has grown over years: I work my way into what is already there and design so that it can actually be built with your team and your hardware.

  • System and software architecture for embedded and distributed systems
  • Implementation in C/C++, Python, Rust, Go
  • Architecture and code analysis of existing systems
  • Maintenance and migration of legacy code
  • From prototype to series maturity

Embedded & robotics

Firmware, drivers, operating software and control — from microcontroller to edge compute node. From more than ten years of mechatronic development I know where software meets electronics and mechanics — and what usually makes projects fail at that boundary.

  • Microcontrollers (STM32, ESP, AVR, NXP), real-time systems
  • Embedded Linux (Yocto), ROS, NVIDIA Jetson
  • Buses and sensors: CAN, SPI/I²C, 433/868 MHz
  • Networking: TCP/IP, Bluetooth LE, MQTT, ZeroMQ
  • Control engineering, kinematics, computer vision, SLAM
  • Development in accordance with ISO 26262, IEC 61508, ISO 10218/13482

Local AI & LLM infrastructure

Generative AI on your own premises — worth it when sensitive data must not leave the building, when token costs need to stay predictable at high volume, or when independence from cloud providers is required. Sizing, setup, operation and integration into your engineering workflows.

  • GPU servers: sizing, setup and operation (Linux)
  • LLM inference with SGLang and vLLM
  • Quantized open-weight models: GLM, DeepSeek, Qwen, Kimi
  • LLM harnesses and agent tooling: tool/API integration, sandboxing, coding agents
  • Automation of development and documentation workflows

Industry experience

  • Robotics & agricultural technology
  • Automotive
  • Aerospace
  • Media
  • Research & development

How I work

From one hand

Requirements, architecture, implementation and testing stay in one pair of hands. I work out the requirements together with you, design the architecture and build it myself — what I learn during implementation feeds straight back into the design. You get one point of contact who knows the system completely, from concept to code.

Fast iteration cycles

I deliver a working build early and extend it in short cycles. You see progress on the real system instead of in a status report, and wrong assumptions surface while they are still cheap to correct. I work within your processes and tools — Git, issue tracker, code reviews, Scrum or whatever is established at your company.

Handover without dependency

What I build should be something your team can carry on without me. That means tests that pin down the design, documentation that records the architectural decisions and the reasons behind them, and reviews together with your developers — instead of knowledge that only lives in my head.

AI as a tool, not an autopilot

I use coding agents and local LLMs in my own development work; they speed up routine work, research and testing. Responsibility for the result stays with me: code I hand over is code I have read, understood and tested. The models run on my own hardware, so your code does not leave the building.

Selected projects

Local AI infrastructure & LLM tooling

since 2023 · io-com.eu · own research & development

Setup and operation of local LLM inference servers (SGLang, vLLM) on self-specified GPU hardware. Development of LLM harnesses and agent tooling: tool and API integration, sandboxing for coding agents, automation of development and documentation workflows. Evaluation of quantized open-weight models (GLM, DeepSeek, Qwen); assessment of data protection and GDPR aspects of on-premise operation.

Result: productive on-premise LLM infrastructure with several models in daily use.

Firmware for digital film cameras

since 2022 · ARRI · senior embedded developer

Feature development for camera firmware (C/C++, Go, Python); software architecture, including the design of an IPC/RPC framework. Architecture and implementation of a test automation framework; use of locally hosted coding agents as a development tool.

Result: firmware components and test automation in productive use.

Mobile robots for agricultural plants

2022 · plant manufacturer · software architect

System and software architecture for mobile robots; consulting on robotics software components.

Result: architecture adopted as the basis for series development.

Agricultural robot prototype

2020–2021 · engineering service provider · tech and team lead

End-to-end development of a harvesting robot: system architecture and requirements across mechanics, electronics and software. Embedded development (STM32), setup of the edge compute hardware (NVIDIA Jetson, Raspberry Pi), operating software with ROS (C++, Python): kinematics, trajectory planning, drivers, control.

Result: working prototype, proven in field trials.

Collaborative robot

2018–2020 · engineering service provider · tech and project lead

Demonstrator for natural human-robot interaction: kinematics and collision avoidance (MoveIt), deep-learning computer vision (object detection, hand tracking, grasp pose estimation), on-device speech recognition (Kaldi), a framework for robot behavior, overall system integration.

Result: fully integrated demonstrator, presented at several events.

Humanoid robot (research)

2012–2013 · DLR (German Aerospace Center)

Control algorithm for a robot with variable-elastic joints: controller design with stability proof, implementation in Simulink, tests and analysis on the real system.

Result: diploma thesis (grade 1.0) and a widely cited paper.

The complete project history since 2007 — from engine control units to aircraft navigation and big-data visualization — is available on freelancermap.

Skills

Programming languages

  • C/C++ (15+ years)
  • Python (15+ years)
  • Rust (3+ years)
  • Java (3+ years)
  • Matlab/Simulink (3+ years)
  • C#/.NET
  • Go

Embedded & robotics

  • Linux (20+ years)
  • ROS (5+ years)
  • Real-time systems
  • STM32
  • ESP
  • AVR
  • NXP
  • NVIDIA Jetson
  • DGX
  • CAN
  • TCP/IP
  • Bluetooth LE
  • SPI/I²C
  • 433/868 MHz
  • ZeroMQ
  • MQTT
  • ProtoBuf
  • gRPC
  • IoT

Local AI & LLM

  • SGLang
  • vLLM
  • GLM
  • DeepSeek
  • Qwen
  • Kimi
  • Quantization
  • GPU servers
  • LLM harnesses
  • Agent tooling
  • Edge AI / on-device inference

Architecture & methods

  • System architecture
  • Requirements engineering
  • Rapid prototyping
  • Tech/team lead
  • Test automation
  • Scrum

Control & algorithms

  • Control engineering
  • Simulation
  • Computer vision
  • Machine learning
  • SLAM
  • Graph theory
  • Linear algebra

Standards

  • ISO 26262
  • IEC 61508
  • ISO 10218
  • ISO 13482

Contact

  • Email

Availability on request · remote and on-site

Opens your own email client with the prepared message — no data is sent to any server.

Legal notice (Impressum)

Information according to § 5 DDG (German law):
Andreas Daasch


Phone:
Email:

Privacy

This website uses no cookies, no tracking and no analytics services. The contact form does not transmit any data to a server; it merely opens your own email client. If you contact me by email or phone, your details are used exclusively to handle your inquiry and are not passed on to third parties.