Modernize the legacy without stopping the business
We strangle the old system gradually, with observability and rollback, instead of betting everything on a from-scratch rewrite. And with Build-Operate-Transfer, you end up owning the system.
The problem we solve
Almost every mature company carries a legacy system nobody wants to touch: it works, it sustains the operation, but it is fragile, poorly documented, and expensive to evolve. The pressure to "modernize" often becomes the riskiest decision on the market — rewrite everything from scratch, in parallel, and do a heroic cutover.
That bet fails more than it succeeds. The big-bang rewrite freezes new features for months, recreates bugs that had already been fixed, and runs into business rules hidden in the old code that only surface in production. The incremental path — with the old system still running — is what most companies should choose. And when it ends, you need to end up owning the result.
How we work
We start with a risk inventory: what the system does, what it depends on, where the fragile points are, and which business rules are hidden. Before touching anything, we wire observability to understand the real production behavior — because sometimes the diagnosis reveals that a rewrite would be waste. That was the case in a surgical fix where swapping UUID v4 for v7 yielded +260% and avoided an entire rewrite.
When a rewrite is justified, we apply incremental strangling (strangler fig): a compatibility layer routes part of the traffic to the new module while the old one keeps serving the rest. We modernize one piece, validate with a benchmark, and only then move on. Every step has rollback prepared. That is how we ran the multi-tenant auth migration for a European retail SaaS, without stopping the operation, and the monorepo restructure (pnpm + Nx) for an ESG startup.
For those who want to modernize without building a team from scratch, we offer the Build-Operate-Transfer model: we rebuild at a fixed price, operate it on a monthly basis, and transfer ownership to your team, with an optional fractional tech-lead tail.
What we deliver
A system modernized in stages, with the business running the whole time, observability wired, and the knowledge transferred. Without the leap in the dark of a total rewrite — and with the client ending up owning what we built. Freedom, not dependency.
Tell us the scenario at /en/contact and we respond with feasibility within 24 business hours.
- Risk inventory of the legacy system and its dependencies
- Incremental strangling strategy (strangler fig)
- Monolith-to-services migration when it pays for itself
- Observability and rollback at each step
- Build-Operate-Transfer model: rebuild, operate, and transfer ownership
- Knowledge transfer so the internal team can take over
Investment ranges
Micro Project
PoC, institutional site, WhatsApp and small chatbots. Non-regulated sector, or your first AI project.
$8,000 – $20,000
- Delivery in weeks
- RAG + light harness
Small Project
Well-defined scope: targeted automation, lean MVP, focused integration.
$20,000 – $70,000
- Fixed scope
- Delivery in weeks
Medium Project
RAG chatbot, enterprise AI agent, SaaS MVP, performance execution.
$70,000 – $220,000
- Dedicated architecture
- Integrations
Large Project
Legacy modernization, system rewrite, multi-phase transformation.
From $230,000
- Multiple phases
- Dedicated team
Qualitative ranges. The exact figure comes out of Discovery, and is 100% credited toward the project.
FAQ
Why not rewrite everything from scratch?
Because a big-bang rewrite is the most expensive and risky way to modernize. You freeze features for months, recreate old bugs, and discover hidden business rules too late. The strangler fig delivers value at every step and keeps the business running. Sometimes the best decision is not to rewrite at all: once we swapped UUID v4 for v7 in a surgical performance fix (+260%) and avoided an entire rewrite.
What is the Build-Operate-Transfer model?
We rebuild the system at a fixed price, operate it on a monthly basis while it stabilizes, and then transfer ownership to your team — with an optional fractional tech-lead tail. The end of the contract is you owning it, autonomous and without lock-in. Freedom, not dependency.
What if our system has no documentation?
Common. We start with a risk inventory and wire observability to understand the real behavior before touching anything. The hidden business rules surface in the diagnosis, not in production.
How does it start?
With Discovery, which maps dependencies, risks, and the strangling order. The estimate comes as a qualitative range, credited if the project moves forward.