We Inherit Code Other Developers Built
It usually starts with an email. "Our developer's gone quiet and we have a system nobody else understands."
We've had this conversation more times than we can count. The specifics vary, but the anxiety is always the same: your business depends on software that's running, right now, serving customers and processing orders. And the one person who understood how it works has stopped answering their phone.
A software takeover is a structured handover of an existing system to our team. We secure your access, run a source code audit, stabilise what's there, and give you an honest assessment of whether to continue with it or start fresh. In our experience the situation is almost always recoverable, and you don't have to keep working with us once you have the assessment in hand.
Dealing with this right now: urgent cases get priority triage, often within 24 hours. Tell us what you're facing and we'll give you a straight answer.
What we do first
Before we write a single line of code, we need to understand what you have and make sure you actually control it. The first phase is methodical, unglamorous, and critically important. It runs in a fixed order, because securing access has to come before anything else.
Access recovery
Source code repositories, hosting accounts, domain registrars, DNS management, database credentials, third-party API keys, payment processor accounts. We build a complete inventory of every service your application depends on and verify that you (not your former developer) control each one.
Immediate security
We change passwords and revoke access tokens that your previous developer still controls. If the departure wasn't amicable, this happens on day one. Your system needs to be secured before anything else.
Only once you hold the keys do we turn to keeping the system upright while we look under the bonnet.
Stabilisation
We make sure backups are running, monitoring is in place, and the system isn't about to fall over while we conduct the full audit. Think of it as making sure the patient is stable before running diagnostic tests.
This triage phase typically takes a few days. For urgent cases where a system is actively failing, we can prioritise and start within 24 hours.
The audit
Once access is secured and the system is stable, we conduct a thorough source code audit. This is where we read more than we write. We need to understand what was built, how it was built, and what state it's in before we can recommend a path forward.
The code audit covers four areas:
Code quality
We assess whether the codebase is well-structured and maintainable, or held together with workarounds and technical debt. That means architecture, naming conventions, separation of concerns, and whether another developer could reasonably pick this up and work with it.
Dependencies and frameworks
We check the framework version, how far behind the dependencies have fallen, and whether the packages it relies on have known security vulnerabilities. An application running Laravel 7 with three-year-old packages has a very different outlook to one on the current release.
Security posture
Authentication, authorisation, data encryption, input validation, SQL injection protection. We check the areas where a gap could expose your business or your customers' data. This isn't theoretical: inherited systems with weak security practices are a recurring finding. Our security and operations work picks up from here.
Test coverage and documentation
We look for automated tests and documentation explaining how things work. The presence or absence of these tells us a lot about how confidently we can make changes without breaking something unexpected.
We're honest about what we find. If the codebase is solid and just needs a new pair of hands, we'll tell you that. If it's a mess, we'll tell you that too, along with what it means for your options.
Three possible verdicts
Every takeover ends with one of three recommendations. We don't have a preference for which one it is. Our job is to give you an honest assessment so you can make an informed decision. In our experience most systems land on the first verdict, and very few need the third.
Maintain and improve
The most common outcome in our work. The codebase is in reasonable shape. It needs some cleanup, dependency updates, and security patches, but the foundation is sound. We take over ongoing maintenance and begin making improvements. This is the least disruptive and least expensive path.
Stabilise, then build
The system has significant issues, but it isn't beyond saving. It needs a period of focused remediation: fixing critical bugs, addressing security vulnerabilities, upgrading dependencies, and adding tests. Once stable, this kind of legacy software system becomes a viable platform for new features and improvements again.
Plan a replacement
The least common outcome, and one we never recommend lightly. Sometimes a codebase is so far gone that the cost of fixing it exceeds the cost of rebuilding. When that's the case, legacy software modernization is the safer route: we help you plan a migration so you're never left without a working system, with the old one running while the new one is built alongside it.
The verdict is based on a sober assessment of the code, the cost of each option, and the risk to your business. We lay out the numbers and the trade-offs. You make the call.
Find out which verdict your system would get
That's exactly what the audit answers. Book a call and we'll tell you where you stand before you commit to anything.
Talk to us →What you get
At the end of the triage and audit phase, you receive a written assessment. Not a vague summary. A detailed, practical document that covers:
-
Access inventory A complete list of every service, account, and credential your application depends on, with confirmation of what you control and what still needs to be recovered.
-
Codebase health report An honest evaluation of the code quality, architecture, test coverage, and technical debt. Written in plain language, not developer jargon.
-
Security assessment A summary of any vulnerabilities or risks we identified, ranked by severity, with recommendations for immediate action.
-
Recommended path forward Our verdict (maintain, stabilise, or replace) with a costed roadmap covering the next 3 to 12 months. You'll know what it costs before any further work begins.
This assessment is yours to keep regardless of whether you carry on with us. There's no obligation to commit to further work, and no lock-in: it gives you the information to make a clear-headed decision about your software's future, whoever ends up doing the work.
Who this is for
Software takeover is the right service if any of these situations sound familiar. The first two are about a developer relationship breaking down.
The other two are about inheriting something you never chose, where the worry is what you don't yet know.
You're not the first person in this situation, and you won't be the last. What matters is that it gets resolved properly. If you'd rather avoid the situation entirely next time, our software maintenance page explains how ongoing care stops these problems arising, and build vs buy covers the decision behind a replacement.
Get your system under control
Tell us what you're dealing with. We'll assess the situation quickly and give you a straight answer about what it'll take to resolve. Urgent cases get priority triage, often within 24 hours.
Book a call →