Fari Software GmbH

Your engineering partner for existing systems — from acute problems to ongoing development.

I take on what's hard: debugging, performance, stabilization. And I stay on board when teams need lasting reinforcement. Focus: C++, Python, embedded and systems-level environments.

  • C++
  • C#
  • Python
  • Embedded
  • Systems-level environments

01Symptoms

Does this sound familiar?

Existing systems rarely fail spectacularly. It gets harder gradually: changes take longer, bugs resist isolation, and nobody can say for sure where the cause lies.

  • Crashes or sporadic misbehavior nobody can cleanly explain.
  • Performance problems with no obvious cause.
  • Grown-over code no one confidently understands anymore.
  • Technical debt that makes every change risky and slow.
  • Bugs that only appear on target hardware — and won't reproduce in the lab.
  • Fragile test and deployment workflows that cost time and stall releases.

That's where I start: at the cause, not the symptom.


02Services

What I actually help with

No off-the-shelf development. Targeted support where existing systems get difficult — and reliable development afterwards.

01

Debugging & root-cause analysis

Crashes, race conditions, memory issues, sporadic misbehavior — including directly on embedded target hardware.

02

Performance analysis & optimization

When systems slow down, tip over under load, or devour resources. Measure first, then optimize.

03

Stabilization & modernization

Making grown systems with legacy code and technical debt maintainable and changeable again — targeted, no big-bang rewrite.

04

Development & relief

Building features in existing systems, automating tests and deployments — so your team makes progress again.

How I work

I don't come for slide decks and moderation. I come when a technical problem needs solving — and stay when it becomes more.

  • Fast, independent onboarding into existing systems
  • Root-cause analysis instead of symptom treatment
  • Pragmatic improvements with maintainability in mind
  • Direct collaboration, short paths, clear responsibility
  • Minimal supervision overhead on the client side

Who this fits

  • Teams that need to evolve, stabilize, or rescue an existing technical system
  • Teams with clear points of contact and short decision paths
  • When fast technical support is needed
  • When a problem should get solved, not discussed for months

03Case studies

Selected engagements

Anonymized examples from real projects — industries and details deliberately generalized.

BioTech · Embedded Linux

Sporadic crashes in device software

Symptom
The C++/C# control software of a liquid-analysis device keeps crashing. Not reproducible — and nobody knows why.
Approach
Analyzed crash dumps, memory and runtime behavior directly on the embedded Linux system — valgrind, ThreadSanitizer, gdb. Two suspects remained: memory management and multithreading.
Outcome
Causes fixed, the device runs stable. Plus a write-up the team now uses to avoid similar bugs on their own.

Semiconductors · Test & measurement

Made a C++ test system scriptable in Python

Symptom
A semiconductor tester needs Python scripting. The C++ software has grown over years — and measurement performance must not suffer.
Approach
Embedded a Python interpreter via pybind11, auto-generated the wrappers. Then measured instead of guessing: fewer IPC calls, tuned multithreading.
Outcome
The tester is scriptable in Python — and got faster in the process, not slower.

Sensors · Industrial

Modernized a grown Python monolith

Symptom
A Python monolith grown over years: hard to maintain, at its limits in the performance-critical spots.
Approach
Rebuilt step by step towards microservices. Ported critical paths to C++ (pybind11), hardened safety-relevant logic, built unit and integration tests plus a containerized test environment.
Outcome
The architecture holds up again: critical paths run in C++, changes are covered by tests.

04Engagements

Ways we can work together

Depending on the situation, I start differently — from a first assessment to long-term collaboration.

01 Entry

Technical first assessment

For concrete problems where clarity is needed first: what is likely the real problem? How to approach it sensibly? Is a deeper engagement worthwhile?

Unclear technical problems

A first read before committing to bigger work

An experienced technical outside perspective

02 Diagnosis

Analysis & recommendation

I analyze a concrete problem in a structured way — and deliver a clear assessment, priorities, and next steps for your team.

More complex technical situations

Grown-over systems with several possible causes

Orientation and a structured way in

03 Hands-on

Direct technical support

Hands-on work inside the system: analyze, stabilize, optimize, develop — remote or on site, one-off or ongoing.

Acute technical bottlenecks

Concrete problems that need implementation

Lasting reinforcement for the team

Many projects start with one concrete problem — and grow into long-term collaboration. We'll figure out the right format case by case. Tell me briefly what it is about →


05About me

Fari Software GmbH

Software engineering from Böblingen, near Stuttgart

AutomotiveSemiconductorsTest & measurementBioTechLogistics

Fari Software is the specialized GmbH of Matthias Spiller, based in Böblingen, Germany. I make existing technical systems manageable again — and keep developing them once the acute pressure is off.

I work hands-on: reading code, debugging, measuring, optimizing. Concept papers are not my business.

When a project needs more hands, I bring in experienced developers from my network.

Your main contact

Matthias Spiller

Matthias Spiller

Managing director & software engineer

Over 20 years in complex technical systems — C++, Python, embedded, systems-level environments, including safety-critical contexts in automotive and biotech. "Fari" is Esperanto for: to do, to make.

What clients say

“Once a task is assigned, it simply gets done to a high standard, without the need for follow-ups. Matthias brings a rare mix of technical expertise, ownership, and clarity that I’d recommend to any team without hesitation.”
Project lead, software
“His expertise in C++ and C#, particularly in embedded systems and CAN protocols, was instrumental in improving our microcontroller library and firmware. Beyond his technical skills, Matthias was a pleasure to work with.”
Team lead, biotech

Source: LinkedIn ↗

06Contact

Let's talk.

A concrete problem — or the question whether I'm the right fit? Drop me a short note. I usually reply within 24 hours with a first assessment.

Available for new engagements

info@fari-software.de