$ cargo build --release
Robust and Flexible Software for Critical Systems
We build applications that hold up in production for years: written in Rust, on long-lived, maintainable architecture — and designed to be thoroughly testable.
#[tokio::main] async fn main() -> Result<()> { let listener = TcpListener ::bind("0.0.0.0:8080") .await?; serve(listener, app()).await?; Ok(()) }
#values
What we stand for
Six principles behind every system we build.
Rust wherever it matters
Memory safety and a strict type system rule out whole classes of bugs before the code ever runs. Where robustness counts, we build in Rust.
Code architecture built to change
Clear boundaries and testable modules keep a codebase maintainable for years — and flexible when requirements or technologies change.
Automated tests
High coverage with unit and integration tests. Behaviour is pinned down in code, so changes ship with confidence instead of fear.
Easy to understand
Code structured so new stakeholders find their way, and documentation written so everyone knows what the system does and why.
Measurable in production
Tracing and metrics via OpenTelemetry show what the system actually does in production: latencies, errors, load. Decisions rest on measurements — not on guesses.
Security, taken seriously
Security is never finished. We keep dependencies few, audited and current, revisit threats as the system evolves, and treat each finding as work to do.
#services
Our Services
Four ways to work with us.
Design and build
A software system designed and implemented end to end: architecture, implementation in Rust where it matters, tests, documentation and telemetry — handed over ready to run.
From prototype to production
You have an MVP, a proof of concept or a legacy codebase. We stabilize it, add tests, refactor where needed, put observability in place and hand it over so your team can run it.
Tests and benchmarks
A complete test suite for your existing system: unit and integration tests that pin down behaviour, plus benchmarks that catch performance regressions before your users do.
Untangle and refactor
For systems that have become hard to change: we measure coupling and cohesion with our own tool TangleGuard, rework the design where it hurts, and refactor step by step — without stopping delivery.
#references
Projects running in production
A selection of systems we designed, built, or pulled back from the brink.
Holzvermessungs Geräte · 2016
Rebuilding a legacy application in Rust
We supported the team through the rebuild: an onion architecture with the domain logic in Rust and Crux as the stable core, UI and device integration as replaceable shells around it, shipped as a multi-platform app built with Flutter.
Sichere Kommunikation · 2026
From proof of concept to production
We stabilized the software for the hardware test lab: reproducible test runs against the real device instead of a model of it — from proof of concept into continuous operation. Handover with documentation and an operations runbook for the in-house team.
E-Learning Plattform · 2026
Architecture review before rollout
We reviewed the platform's architecture — the dependency analysis done with our own tool, TangleGuard, backed by a review of the code. The result is a report with a prioritized backlog — first and foremost the tests that make stable further development possible.
#tangleguard
TangleGuard
Our own tool for keeping software architecture under control.
TangleGuard analyzes the dependency structure of a codebase: layers, packages, coupling and cohesion. It shows the architecture as it actually is, not as the diagram claims — so design decisions rest on evidence and drift is caught early. No off-the-shelf tool does this the way we need it, which is why we built it ourselves.
- ✓
Design with evidence
Measure coupling and cohesion before and after a change, and find the cheapest cut to break a cycle.
- ✓
Always in view
The real architecture, visualized from the code — layers, dependencies and violations at a glance.
- ✓
Monitored continuously
Rules are checked on every change, so the architecture stays the one you decided on instead of eroding.
$ tangleguard -l rust validate INFO Workspace scan completed in 312ms # Validation ## Rules All 184 cross-package dependencies are allowed by the rules. ## Circular dependencies No circular dependencies found.
#contact
Ready for Software That Lasts?
Let's talk about making your application robust, maintainable and testable — from design to operations.
Jan Arends
Founder & your contact