Broken in production,
or abandoned mid-build.
Something is failing and the person who built it is gone, unresponsive, or was never going to finish. We take over unfamiliar code, find out what is actually happening, and get you back to a working state. Prepaid in Hour Blocks of 6, 12 or 24 hours - the first block is usually assessment, and the assessment is yours either way.
Within two business days
Your message goes straight to the studio. No sales queue, no account manager in between.
Prepaid Hour Blocks
Buy 6, 12, or 24 hours up front at $30/hr. Unused hours never expire.
10 live products
PHP, Python and JavaScript in production, and a habit of reading code we did not write.
You own the code
Full source, in your repository, with the reasoning written down. No lock-in to us or anyone else.
Six versions of
the same bad week.
Rescue work looks chaotic from the inside and is fairly predictable from the outside. If one of these describes you, we have been here before.
It broke and it is costing money
Checkout fails, emails stopped sending, a page throws a 500 since the host upgraded something. The first move is not to start editing code, it is to establish what changed and when - deploy history, server logs, provider status, configuration drift. A fix applied before the cause is understood usually creates a second, subtler bug that surfaces a fortnight later.
- Timeline established before any change
- Reproduction on a copy, not on production
- Server, application and provider logs read
- Root cause fixed, not the symptom hidden
- A regression test so it cannot come back
- A plain-language write-up of what happened
The developer stopped replying
The most common rescue: an agency or freelancer went quiet three weeks before launch, and you have a repository, a staging link that no longer loads, and no idea how close it actually was. The first thing you need is not code, it is an honest status - what works, what is scaffolding, what is missing entirely, and what the remaining work realistically costs. That assessment is the deliverable of the first Hour Block.
- Honest completion assessment, feature by feature
- Working versus scaffolded versus absent
- Remaining effort estimated in hours
- What to finish and what to cut
- Whether any of it should be rebuilt
- Yours to take elsewhere if you prefer
Getting control back
Sometimes the bug is not in the code at all: nobody knows where the site is hosted, the domain is registered to a former contractor, or the only copy of the code is whatever is running on the server. Recovering ownership comes first, because everything else is built on it. The live code can usually be pulled down and put into version control the same day, which at minimum stops the situation getting worse.
- Live code recovered into version control
- Hosting, domain and DNS ownership traced
- Every credential rotated as a matter of routine
- Running code compared against the repository
- Backups verified by actually restoring one
- A clear list of what is unrecoverable
The bug nobody can reproduce
The worst category: it works when you watch it. Intermittent failures are almost always a race condition, a job running twice, a cache serving something stale, a timezone assumption, or a third party that is slow rather than down. These are found by instrumenting rather than staring - adding correlation identifiers and targeted logging so the next occurrence leaves evidence instead of a shrug.
- Targeted logging added before guessing
- Correlation identifiers across the request path
- Duplicate job and race condition hunting
- Cache and stale-data investigation
- Timezone and locale assumptions checked
- Evidence captured for the next occurrence
When the data is already wrong
Often the code bug has been fixed and the damage remains: duplicate orders, half-written records, totals that no longer add up, a failed import that ran three times. Cleanup is its own careful job. It happens on a restored copy first, as reversible scripts with a dry-run mode that reports what it would change, and with a record of every row touched.
- Scope of the damage quantified first
- Dry-run mode before anything is written
- Rehearsed on a restored copy
- An audit record of every changed row
- Constraints added so it cannot recur
- Reconciliation against an external source
What happens once it is stable
Once the emergency is over, most people discover the real problem was never the bug - it was having nobody who knows the system. We can stay on as the studio that does, using the same prepaid Hour Blocks rather than a separate contract. Or we can hand everything over properly and you never hear from us again. Both are fine, and we will not make the second option deliberately awkward.
- Continuity from the same prepaid Hour Blocks
- No separate contract to negotiate
- Or a clean, documented handover
- Knowledge written down, not held hostage
- Nothing that only we can run
- Access you can revoke at any time
Including the part
you can take elsewhere.
A rescue should reduce your dependence on developers, not transfer it to a new one. The assessment is deliberately written so another developer could act on it without us.
A written assessment
What works, what does not, what is missing, what it would cost to finish, and what we would abandon. Yours to keep and to shop around with.
The actual cause, explained
Not just a fix. What broke, why it broke, why it was not caught, and what would have to be true for it not to happen again.
Ownership recovered
Code in version control under your account, credentials rotated, hosting and domain traced back to you, backups verified by a real restore.
A regression test
Whatever broke gets a test, so the same failure cannot return quietly through a future change by anyone.
How to run it
Local setup, deployment, rollback and the first things to check when something looks wrong - the document that was missing when you called us.
A clean exit
You can revoke our access at any point and nothing stops working. No component only we can run, no knowledge held back as a bargaining chip.
Why unfamiliar code
is not a problem here.
Client work stays under NDA, so what we show is what we run ourselves, and that includes a habit of reading someone else's code quickly.
Reading code we did not write
The first hours of a rescue go into reading: routes, migrations, logs and deploy history, until we can say what works and what does not. That reading is written down, so it stays useful whether or not we continue.
CodeIgniter maintenance10 products, many stacks
Laravel, Django and Python, Vue. In a rescue you do not get to choose what you inherit, and breadth is what lets us say yes to the app you actually have.
See the productsSlashKeys
Laravel 13 with self-hosted mail through Postfix and OpenDKIM. Relevant because half of rescue work happens on the server rather than in the code, and that is not something we subcontract.
Read the case studyFour steps, no discovery call
you have to sit through.
For a rescue the first Hour Block buys an honest assessment rather than a guess, and that assessment is yours whether or not you continue with us.
Tell us the problem
A few sentences on what you have and what you need. Rough is fine - we ask the questions that matter and tell you honestly if it is not a fit.
Pick an Hour Block
Prepay a block of hours - 6, 12, or 24. The block is the budget: we work until it is used, or you top up.
Work in the open
Stabilise first, then fix the cause, then write the regression test. Each step explained as it happens rather than saved for a final report.
Handover and support
Ownership back in your name, the runbook written, and access you can revoke the moment you want to.
Bought in
prepaid Hour Blocks.
No volume games and no agency margin on top. You buy the block of hours that fits the size of the job, so you know the number before we start rather than after.
Typically enough for a focused fix, a small feature, or an integration you are stuck on.
Start with StarterTypically enough for a working prototype, or one well-scoped feature built and shipped.
Start with StandardTypically enough for a larger build with integrations, auth, or billing wired in.
Start with ProEvery Hour Block is hours at $30/hr with no discount. It is a bucket of time, not a fixed-scope deliverable. Unused hours do not expire - roll them into the same project or a later top-up. If the work runs long, you buy another block; nothing is billed without you agreeing to it first.
Frequently asked.
How fast can you start?
We are not a 24-hour operations desk, so we will not promise you a one-hour response we cannot keep. What we do promise is a reply within two business days, and that if we take the job we start on it rather than queueing it behind three others. If your situation genuinely needs round-the-clock coverage, we will tell you that in the first reply instead of taking your money.
What is an Hour Block, and what if the job takes more or fewer hours?
An Hour Block is a prepaid block of hours: Starter is 6 hours for $180, Standard is 12 hours for $360, Pro is 24 hours for $720. It is a bucket of time, not a fixed-scope deliverable. Unused hours do not expire and roll into the same project or a top-up. For a rescue, the first Hour Block is usually spent on assessment, and you get that written assessment whether or not you continue.
The previous developer left no documentation. Can you still take it over?
Yes. That is the normal condition of a rescue, not an obstacle to it. What we need is the code, the database and access to the server or a copy of it. From those three we can usually reconstruct how it is built and deployed. Reading unfamiliar code quickly is the core skill this job is made of.
We do not have the source code, only the live site. Now what?
Then the first job is getting it back. The running code is on the server, so it can usually be pulled down and placed into version control immediately, which also means the next person to touch it cannot overwrite something irrecoverably. Missing pieces such as build sources or private packages get identified early so you know exactly what is and is not recoverable.
Will you tell us if it is not worth fixing?
Yes, and it happens. Sometimes a half-finished module is cheaper to rebuild than to untangle, and occasionally a whole project is. You get that opinion with the reasoning, not a quote for whatever generates the most hours. An assessment that tells you to stop spending money is still a useful thing to have bought.
What about access and security after a developer leaves badly?
Treat every credential they touched as compromised and rotate it: server keys, database passwords, third-party API keys, admin accounts, domain and hosting logins. We also check what is actually running against what is in the repository, since that gap is where unpleasant surprises live. None of this implies bad faith by the previous developer; it is simply what you would do for any departing administrator.
Which stacks do you work with?
PHP in most of its forms, including Laravel, CodeIgniter, Symfony, WordPress and WooCommerce, plus Python with Django, and front ends in Vue. Breadth matters in rescue work because you rarely get to choose what you inherit, and the app is usually two or three of those stacked on top of each other.
How do we start?
Send a few sentences through the form on this page: what is failing, when it started, and whether anyone still has access to the code and the server. You get a reply from us directly, usually within two business days, with an honest read, including if the honest answer is that you need someone else.
Tell us what broke.
What is failing, when it started, and whether anyone still has access to the code and the server. A few sentences is plenty - we read every message and reply within two business days with an honest read, including if the honest answer is that you need someone else.
Prefer email?
[email protected]