Takeover

    Taking over an unfinished software project.

    The developer stopped replying. The agency ran the budget out at seventy per cent. The one person who understood the deployment left in March. However it happened, you are holding a repository nobody can explain and a set of quotes you have no way to judge. The first job is not to build anything. It is to find out what you actually have.

    Signs the project is in trouble

    You do not need all of these. Three is usually enough that an audit pays for itself.

    Deadlines that nobody trusts

    The plan still exists and still gets updated, but no date on it has survived contact with a week of real work in months.

    You cannot check the progress

    Updates arrive as screenshots and percentages. Nothing is deployed anywhere you can open and click through yourself.

    One person holds everything

    If they stop answering, nobody else can deploy it, explain the data model, or say which parts are finished and which are half-built.

    The estimate keeps growing

    Each change request costs more than the last, and the reasons are technical enough that you cannot tell whether they are fair.

    Bugs come back after a fix

    The same problem reappears in a slightly different place, which usually means no tests are holding the behavior down.

    Nobody can name the risks

    Ask what happens if the database is lost or a credential leaks, and the answer is a shrug rather than a backup and a rotation plan.

    What the audit tells you

    A written report, in language you can act on, that you own and can take to any other firm.

    What is finished, honestly

    Features that work, features that look finished and are not, and features that exist only in the last invoice.

    What is load-bearing

    The parts the rest of the system depends on, which is what decides whether this can be extended or has to be redone.

    What is actually risky

    Exposed credentials, missing access checks, data that is not backed up, and anything that bites the moment you have real usage.

    Whether to extend or rebuild

    A straight recommendation with the reasoning, including when the answer is that it is in better shape than you were told.

    What each path costs

    Two numbers and two timelines, with the reasoning behind each, so the decision is yours to make rather than ours to make for you.

    Why the boring step comes first

    Before any new feature gets built, the project has to be something a person can check out and run. That usually means reconstructing the environment, getting the deployment reproducible, writing the setup instructions and the runbook, and putting the credentials somewhere sane. It is unglamorous, it is quick, and it is what stops the next handover being another crisis.

    How the takeover runs

    Four stages, and you can stop after the first one and take the report somewhere else.

    01

    Read the code

    The repository, the infrastructure and the data, before anybody offers an opinion.

    02

    Report in writing

    What exists, what is risky, and what each of the two paths forward would cost.

    03

    Make it deployable

    A checkout that runs, a deploy that repeats, and credentials kept somewhere sane.

    04

    Finish the build

    Extend or rebuild on the plan you approved, with tests where money and access live.

    What you have at the end

    Your own repository

    Full source-code ownership, with a commit history that reads as a sequence of decisions.

    A deploy that repeats

    Environments, migrations and a pipeline, so shipping stops being one person's ritual.

    The written handover

    Architecture notes, setup instructions and a runbook that someone else has followed.

    A build you can hand on

    The next team starts by reading rather than by running another discovery phase.

    What we need from you to start

    Access to the repository

    Read access is enough for the audit. If there is no repository, we work from whatever is deployed.

    Whatever documentation exists

    Including none at all. A Slack thread and an old proposal is a normal amount to start from.

    Hosting and account access

    Or a list of what you think exists, so we can work out what is actually running and what is being billed for nothing.

    What it was meant to do

    The original scope, even informally, so we can tell you how far from it the build actually landed.

    Answered before you ask

    We only have a login and a zip file. Can you help?

    Yes, and it is a more common starting point than you would think. We work from whatever exists, including a running deployment with no source code at all. Part of what you get back is a repository and the documentation that should have been there from day one.

    How do we know a rebuild quote is honest?

    Get the code audited by someone whose answer is not automatically rebuild. A firm quoting the rebuild has an obvious interest in the verdict. We put the recommendation in writing with the reasoning, and plenty of inherited codebases turn out messy but sound, which makes extending the right call.

    How much does the initial code audit cost?

    It is a small, self-contained piece of work, quoted as one number before it starts and priced well below a full build. You can buy the audit on its own and take the report elsewhere. That is a legitimate outcome and we price it so it stays a real option.

    Can you work with the original developer if they return?

    Happily, if they are willing. Someone who knows why a decision was made saves everyone a week of reading. We do not need them, though, and we will not make the project depend on whether they answer an email. The code is the source of truth.

    How quickly can you get started on this?

    The audit usually starts within days of getting access, because it needs a careful reader rather than a whole team. You get the report and a number before you commit to any of the work it recommends, so the first step costs you very little to take.

    What if the audit says we should start over?

    Then we say it plainly and show the reasoning. A rebuild verdict is the expensive one, so it deserves evidence rather than a preference, and you should be able to hand the report to another firm and have them reach the same conclusion from it.

    Can you finish it if we hire someone in-house later?

    That is a good outcome and we build toward it. Everything gets documented as we go, the code sits in your repository, and an in-house hire can pick it up without a discovery phase. We would rather you left cleanly than stayed because leaving was painful.

    Related

    Tell us what it has to do.

    Describe what you’re building, what it has to do and when it needs to be live. You’ll get back the architecture we’d use, the trade-offs, and a realistic timeline, before anything is signed.