// Already Started
Stalled, abandoned, or inherited — we take over existing codebases, tell you honestly what's salvageable, and finish what someone else started. It starts with a free assessment, delivered in 48 to 72 hours, that's yours to keep whether or not you hire us.
They stopped replying, or they left. You may not have the repository, the server credentials, or any documentation — and nobody can tell you how close to finished it actually was.
Deadlines keep moving, each fix breaks something else, and progress reports stopped matching what you can actually open. You suspect it's going wrong but have no technical read of your own.
It runs the business and no one currently on your team wrote it. Every change is a risk, and the person who knew how it worked is long gone.
It demos beautifully and falls over the moment real users, real data, or a security review touch it. Getting from prototype to production is a different job than the one that got you here.
// The Starting Point
Free
48–72 hour turnaround
Not a “free consultation” — a written deliverable. You end up holding a document you can act on, not a calendar invite and a sales pitch.
No cost and no obligation — you don't have to commit to a build to find out where you stand.
The report is yours to keep — including if you hand it to another developer entirely.
Fixed scope, so it stays free. It can't quietly turn into a billable discovery project.
What you get
Three ways forward, and one of them is walking away. We'd rather you pick the right one than the expensive one.
The assessment is a deliverable, not a sales call. It's yours to keep and act on however you like — including with someone else. You owe us nothing further.
Pick the single thing that's hurting most — the security hole, the broken deploy, the bug losing you customers — and we'll scope that alone before you commit to more.
We take ownership: stabilise it, document it, finish it, and stay on afterwards. Priced once we've seen it — fixed fee where the scope is predictable, hourly where it honestly isn't.
We won't publish a rate card for custom software — any number we put here would be wrong for most of the people reading it. What we will do is tell you exactly how the number gets decided.
Always, and with no obligation. You get the written verdict, the risk map, and the plan whether or not you ever hire us — including if you hand it to another developer.
Once we've seen the codebase and the scope is clear enough to commit to, you get one number and one timeline. No hourly meter, no surprise invoices.
Some work can't be honestly estimated up front — deep unknowns in an inherited system, or a scope that will move as we learn. There we bill hourly, because padding a fixed price for that risk means you pay for it whether it happens or not.
No speculative proposals for work you haven't decided on. Tell us you want it built and we'll price it properly — which is also why the assessment comes first.
// The Part Most Agencies Leave Out
A rescue is worth doing when repairing costs meaningfully less than rebuilding. Sometimes it doesn't — the foundations are wrong, the data model can't carry what you need, or the security debt is deeper than the feature set. When that's what we find, that's what the report says, along with what we'd do instead and roughly what it would cost.
You've already paid once for someone who told you what you wanted to hear. We're not going to be the second.
Most people who come to us have been let down by a developer before. These are the four things they tell us they wish they'd had in writing last time — so we put them in writing first.
You meet the senior engineer who will actually write your code — by name, on the first call. No handoff to a junior once the contract is signed, and no subcontracting your project to someone you've never met.
You own the code the moment it's written, not when the final invoice clears. It lives in your repository, under your account, documented so any developer can pick it up. No lock-in, and nothing held hostage.
Each milestone is something you can open and use — not a percentage of an estimate. If a milestone doesn't land, the next one isn't billed until it does.
Ask and we'll sign yours, or send ours, before you share a repository, a database, or a business plan. We'd rather do the paperwork first than ask you to trust us with it.
Then we'll tell you, and we'll tell you early. Some codebases genuinely cost more to repair than to rebuild, and a few should simply be retired. We'd rather lose the work than take your money to prop up something that won't hold — you'll get the reasoning in writing either way, so you can act on it with or without us.
Often, yes. Recovering access is a normal part of a takeover — we've worked from a live URL, a hosting invoice, a domain registrar login, and not much else. Tell us what you do have and we'll tell you honestly whether it's enough to work from.
No. Assessments are confidential, and plenty of them happen while the original developer is still engaged — usually because something feels wrong and you want an independent read before making a decision. We'll sign your NDA first if you'd prefer.
48 to 72 hours from the moment we have access. It's a fixed scope, so it can't quietly turn into a billable discovery project.
There isn't one, but here's the honest reasoning: we'd rather spend two days finding out whether we can genuinely help than spend two weeks writing a proposal for work we shouldn't take. You get a real document either way — the verdict, the risk map, and the plan — and you're free to act on it with another developer entirely. If we're a fit, you'll know. If we're not, you've lost nothing but the time it took to give us access.
It depends on how predictable the work is. When we've seen the codebase and the scope is clear enough to commit to, it's a fixed fee — one number, one timeline, no hourly meter. When it genuinely isn't predictable, which happens with deeply tangled inherited systems, we bill hourly instead. Padding a fixed price to cover that uncertainty just means you pay for the risk whether or not it materialises, and we'd rather not do that to you. We only quote work you've told us you want to proceed with.
A senior engineer, named before you commit, who stays with the project from the assessment through to delivery. Not a salesperson on the call and a junior on the code.
// Free, No Commitment
Find out where
you actually stand.
Tell us what happened and what you still have access to. We'll tell you honestly whether it's worth saving — in 48 to 72 hours, at no cost, and the report is yours either way.
