Industries/ Startups/ Finishing a stalled build
Software project rescue for the build you were left with.
We start with a written technical review of the half-finished product: what exists, what works, what is unsafe and what only needs finishing. Then we bring the accounts back under your control, put tests around the parts that matter and complete the work.

- Used by
- Founders, investors asking questions and your next engineer
- Takes the place of
- Guesswork, a silent freelancer and a rewrite by reflex
- Connects to
- Your repository, hosting, payment provider and app stores
- Built with
- Our redesigns & rescues service
Where it hurts today
A normal week, before it exists
The story usually starts well. A freelancer or a small agency was hired, early screens looked promising and the invoices were paid. Then replies slowed, deadlines moved and one day they stopped. What remains is a login screen, a database nobody can explain, a staging site that may or may not match the code, and no documentation. Sometimes the code is in a repository you can see. Sometimes it is not.
Meanwhile the business keeps moving. Pilot customers were promised access months ago. An investor asks in every update when people will be able to use it. The founders cannot judge the code themselves, so they are left choosing between two quotes: one agency says it is nearly done, another says it must be rebuilt from scratch. Neither has looked closely, and the gap between them is most of the remaining budget.
There are quieter risks too. The hosting account might be registered to the contractor's personal email. The domain might renew on someone else's card. Keys for the payment provider might sit in a file anyone with the code can read. The contract may never have assigned the code to your company. None of this is visible from outside, and all of it matters when an investor's technical adviser asks who controls the product.
What it does
Finishing a stalled build, feature by feature
A rescue is mostly careful reading, honest writing and unglamorous stabilisation, in that order.
- 01
A written code audit you keep
We read the code, the database, the hosting and the third-party services, then write down what exists, what works, what is unsafe, what must be replaced and what only needs finishing. You own the document whether or not we do the rest of the work.
- 02
Every account back in your name
Repository, hosting, domain, email service, payment provider, analytics and app store listings are listed, checked and moved under your company where they are not already. Passwords and keys the previous team held are rotated, so access ends cleanly rather than politely.
- 03
Fix or rebuild, decided part by part
We judge each part of the product on its own rather than the whole thing at once. A sound payments integration is kept. A half-built workflow is finished. Sign-in with weak password storage is replaced. Each decision comes with a reason you can repeat to a co-founder or an investor.
- 04
Tests around the critical paths first
Before adding anything new, we write automated tests around sign-up, login, payments and the core workflow, so the parts customers depend on cannot break unnoticed while we finish the rest. It is slower at first and much calmer after that.
- 05
Releases that do not depend on one laptop
If the product was deployed by hand from the previous developer's machine, we set up a pipeline that builds, tests and releases from the repository, with a preview environment and a documented way to roll back. Anyone with the right access can ship a change.
- 06
Open-source licences and dependencies listed
We list every library the product depends on, its version, its licence and whether it has known security problems. Outdated or abandoned packages are flagged, and any licence that could oblige you to publish your own code is raised with you before it becomes an investor's question.
A day with it
How the day runs instead
A normal week once the product is stable, the accounts are yours and the remaining work is being finished.
- MondayFounder
The founder reads a one-page status note: what shipped last week, what is next, and any finding from the review that has changed. It is short enough to forward to the lead investor without editing, and it uses the same part names as the review.
- TuesdayEngineer
An engineer picks up the next item on the finish list, a half-built export. The tests around sign-up and payments run on every change, so when a shared function is altered, a failing test points at the problem before anything reaches a customer.
- WednesdayPilot customer
A pilot customer logs in to the preview link and tries the export. Their comments go straight onto the shared board against that item, so the engineer sees them in context rather than in a forwarded email chain.
- ThursdayOperations lead
The domain renewal notice arrives at the company's own address, not a contractor's. The operations lead renews it on the company card and ticks it off the accounts list that came with the review.
- FridayEngineer
The week's changes go out through the pipeline, with a preview first and a rollback ready. The release note is written in plain words for the founders, and the documentation page for the export is updated in the same change.
What it connects to
Works with what you already run
A stalled build already touches several outside services. Part of the work is finding them all and making sure each one belongs to you.
Code repository
The source moved into a repository owned by your company, for example on GitHub or GitLab, with its full history kept where it exists and access limited to the people working on it now.
Hosting and cloud accounts
Servers, databases, storage and backups traced, moved under your company's billing where needed and documented, so you know what is running, what it costs each month and how to restore it.
Payment provider
Live and test keys checked and rotated where the previous team held them, and webhooks confirmed, so subscriptions, refunds and failed payments behave the way your product expects.
Domain, email and app stores
Domain registration, email sending records and any app store listings checked for ownership and moved into your company's name, so a renewal or a store notice never goes to someone who has left.
The first version
Start small, then grow it
A first version should be useful on day one and small enough to get right. This is where we would usually draw the line, and what tends to follow once people are using it.
In the first version
- A written technical review with a keep, finish or replace decision per part
- Every account, key and domain listed and under your company's control
- Automated tests around sign-up, login, payments and the core workflow
- A release pipeline with previews and a documented rollback
- The unfinished core workflow completed and released to pilot customers
Once it is in use
- Replacing the parts the review marked unsafe, one at a time
- Planned features that were never started, reordered by customer evidence
- Performance work once real usage shows where the slow parts are
- Onboarding your own engineer with a walkthrough of the codebase
Buyer's guide
Before you commission one
Four decisions worth settling before anyone, us included, touches the code.
- 01
Finish it, rebuild it or buy a product
Sometimes the honest answer is that a packaged SaaS tool or a no-code platform now does what the stalled build was meant to do, and the custom code should be retired. More often the product is the advantage and the code is worth finishing. The review should answer this part by part, with reasons, before anyone commits more money.
- 02
What to gather first
Contracts and invoices with the previous developer, any statement of work, every login you hold, the domain registrar, hosting and app store accounts, and emails describing what was promised and delivered. A list of features customers or investors were told about helps too. Gaps in this list are findings in their own right.
- 03
Who should own it
One founder should own the rescue: approving access changes, deciding keep or replace, and talking to the previous developer if needed. If an investor has a technical adviser, involve them early and share the review. Someone in the business should also own the accounts list from now on, so the same problem cannot quietly return.
- 04
How you will know it is working
The signals are practical: releases go out from the pipeline rather than one person's machine, tests run on every change, the accounts list shows your company everywhere, pilot customers use the finished workflow, and the bug list shrinks rather than grows. You should also be able to answer an investor's technical questions without phoning anyone.
Terms worth knowing
The words you will meet
- IP assignment
- A signed, written transfer of ownership of work from the person who made it to your company. In the UK, an assignment of copyright only takes effect in writing signed by the person assigning it. In the US, software from an independent contractor is rarely a work made for hire, so an assignment is needed there too.
- Copyleft licence
- An open-source licence, such as the GPL or the AGPL, that can require you to share source code under the same terms in certain situations. The AGPL can apply when users reach modified code over a network, which matters for web products. A licence review finds these before an investor's adviser does.
- Software bill of materials
- Often shortened to SBOM: a list of every third-party component in your product, with versions and licences. It makes security updates faster, licence questions easier and due diligence calmer, and some larger customers ask for one during security reviews.
Handled with care
The details that matter here
Taking over someone else's half-finished work needs as much care with people and access as with code.
Access handed over, not taken
Where the previous developer is still reachable, we ask for a proper handover and keep the tone civil. Where they are not, we work with what you can access and document the gaps. Either way, we rotate every key and password once control is back with your company.
Honest about what we find
Sometimes the code is better than everyone feared. Sometimes a part has to go. We write the findings plainly, separate what is unsafe from what is merely untidy, and do not recommend a rebuild because it would be easier for us. You decide with the facts in front of you.
Customer data handled carefully
If the stalled product already holds real customer or pilot data, we find out where it lives, who can reach it and whether backups exist before changing anything. We work with your data protection lead on anything that looks like exposure under UK GDPR or EU GDPR, and record what we did.
Investor questions anticipated
The review and documentation are written so they can go into a data room: who owns the code and accounts, which open-source licences are in use, how data is stored and how releases happen. We cannot say how an investor will judge it, but nothing in it should surprise you.
Guides
Worth reading first
Questions
What buyers ask first
My developer disappeared. Can you take over the project?
Usually, starting with what you can reach: the live site, hosting, domain, app store listings and any shared drives. That tells us a surprising amount. Getting the source code is the priority, and we help you ask for it clearly and in writing. Then comes the technical review, and only after that a plan to stabilise and finish, so nobody commits to a direction before knowing what is there.
Should we fix our app or rebuild it from scratch?
Part by part, against evidence. We look at whether each piece works, whether it is safe, whether it can be tested and whether another engineer could understand it. A part that passes is kept or finished. A part that fails on safety is replaced. Rebuilding everything is rarely the answer, but where it is, we explain why in writing before anyone commits to it.
Who owns the code a freelancer wrote for us?
Not necessarily you, even if you paid for it. In the UK the author of code is its first owner unless they were your employee, and a transfer of copyright needs a written assignment signed by the author. In the US, contractor-written software rarely qualifies as a work made for hire, so the same applies. We flag what your contract seems to say, but confirming ownership and fixing any gap is a job for your solicitor.
Will you tell us if the previous work was poor?
We will tell you what is there, plainly and without drama. Code written under time pressure often looks rough and still works, and we do not confuse untidy with broken. Where something is genuinely unsafe or misleading, such as a feature that was invoiced as done but does not work, we say so clearly and show you the evidence, so you can decide what to do.
Do we have to hire you for the rest of the work?
No. The technical review is a paid piece of work with its own written deliverable, and it is yours whatever you decide next. Some founders take it to another team or use it to brief an in-house hire. If you ask us to carry on, the review becomes the plan we work from, so nothing is repeated.
Left with a build nobody can explain?
Tell us what you have access to and what was promised. We will explain how a review would work for your product, and we reply within 48 hours.
More for startups
What else we build for startups
Pitch-ready brand identity
A mark, colours, type and a pitch-deck template sized for where you are now, with room to extend later. Investors, first hires and early customers judge credibility on thin evidence, so give them a company that looks as considered as the product.
A narrow first release
One workflow, real accounts and real billing, built on foundations that will not need replacing. Small enough to ship early and put in front of paying customers, so what you build next is decided by what they actually do.
AI inside your product
Smart search, recommendations, summaries or document reading built into your own product, each scoped to do one job well, with the cost per customer measured before the feature goes anywhere near your pricing page.
Metrics your board trusts
Signups, activation, retention, revenue and churn pulled straight from your product and billing system into one live view, so investor updates and board packs stop costing a founder a weekend of spreadsheet work.
Phone apps and store launch
When your product needs an app, we build for iPhone and Android together and handle the store side in parallel: developer accounts, testing tracks, privacy declarations and reviewer notes, so submission never holds up a launch date you have announced.


