Fix the system you have. Keep the business running.
Slow releases, mystery outages, one developer who knows where everything is. We take over legacy applications, make them safe to change, and modernise them one verified step at a time.
The rewrite is the most expensive sentence in software. It sounds clean, takes twice as long as planned, and while it happens the old system still needs fixing. In almost every case a legacy application can be understood, stabilised and modernised in place, with the business running throughout.
We start by making the system observable and testable, then refactor along the seams that matter: the hot paths, the parts that block new features, the parts that wake people up. Frameworks get upgraded, databases get migrated without downtime, and the cloud bill gets rational. Each step is verified before the next.
Understand, stabilise, then modernise.
Audit and risk map
Two weeks reading the code, the database and the infrastructure. You get a map of what is fragile, what is expensive and what is fine, with a prioritised plan.
Stabilisation first
Logging, monitoring, backups you can restore, health checks that do not lie, and the two or three fixes that stop the weekly fire.
Characterisation tests
Tests that pin down what the system does today, so every refactor is checked against reality instead of memory.
Incremental refactoring
Strangler patterns, module extraction, dependency upgrades and cleanup along the paths you actually change, never a big-bang branch.
Framework and database migrations
PHP and Laravel version jumps, Node.js upgrades, MySQL to PostgreSQL, monolith to services only where it pays. Zero-downtime as a discipline.
Move to a sane cloud setup
From a single server or a hand-built account to containers, infrastructure as code and CI/CD, keeping the application unchanged where it does not need to change.
What you get
- A written audit with risks ranked by impact and a step-by-step modernisation plan
- Monitoring, backups and tests in place before any significant change
- Refactored, upgraded code in your repository with every step reviewed and deployable
- Documentation and architecture notes that end the single-developer dependency
- A predictable release process, measured in minutes, not weekends
This is for you if
- Releases are rare and scary, and every change seems to break something unrelated
- The original developer or agency is gone and nobody fully understands the system
- A vendor quoted a full rewrite and you would like a second opinion before spending that
How an engagement runs
You get a senior engineer who delivers like a small team — with a transparent hourly rate, weekly reporting, and no agency overhead. Scale hours up or down as the project needs.
- 01Audit — read-only access, two weeks, a written risk map and a plan you can take to anyone.
- 02Stabilise — observability, backups, tests and the urgent fixes; the fire stops before the renovation starts.
- 03Refactor — weekly increments along the paths that matter, each shipped and verified in production.
- 04Modernise — framework, database and cloud upgrades once the system is safe to change, then handover or ongoing support.
Questions we hear before every engagement
Do we really not need a rewrite?
Rarely. A rewrite is justified when the domain model is fundamentally wrong or the platform is dead. In most cases we can modernise in place faster and with less risk. The audit answers this honestly, including when the answer is "yes, rewrite this part".
Which technologies do you take on?
PHP and Laravel of any age, Node.js, Python, React and older JavaScript frontends, MySQL and PostgreSQL, and applications running on a single server, on hand-built AWS accounts or on other clouds. If it is something else, ask; we will tell you quickly if it is a fit.
Can this happen while we keep shipping features?
Yes, and it should. Refactoring along the paths you are already changing is the cheapest kind. We plan the work so that feature delivery continues, with the refactoring making each next feature easier.
How long does it take?
The audit takes two weeks. Stabilisation usually one to two months. Modernisation depends on the system and on how much you want to change; we plan it in milestones so you can stop at any one of them with a better system than before.
What if we just need the fire to stop?
Then we do the audit and stabilisation and stop there. Many clients keep us on for a few hours a month afterwards; some hand the system to their own team with the documentation we leave behind.
How we think about it
How we rescue and refactor: a platform migrated off a low-code tool, one year later
In 2025 a US client handed us a business platform that runs their partner programme: onboarding, product listings, month...
September 2026
AI Won't Fix Your Broken App
By Ion Anghel · April 2026 A CTO called me last quarter. His pitch, roughly: "We're behind on AI. I want every engi...
April 2026
Health checks that lie: six ways your service says "ready" when it isn't
A health check is a contract between your application and the thing that routes traffic to it. The router asks "can...
September 2026Have a system that needs rescuing?
Flexible hourly / time-and-materials engagements, fully remote, B2B. Direct communication with the engineer doing the work — no hand-offs, no sales pitch.