We've Seen This Before
The call usually comes on a Thursday afternoon. A CTO or VP of Engineering, voice tight with controlled urgency: "Our outsourcing partner has gone dark. We have a demo for investors in six weeks. The codebase is... we're not sure what state it's in. Can you help?"
Over 23 years, we've taken this call more than 20 times. The details vary, but the pattern is remarkably consistent. This article is our playbook — the exact process we follow in the first 72 hours of a project rescue.
The Five Warning Signs
Before we get to the rescue process, here are the red flags that predict outsourcing failure. If you're seeing three or more of these, it's time to act:
- ▹Velocity theater — Lots of commits, lots of "completed" tickets, but the product doesn't actually work end-to-end.
- ▹The knowledge silo — One person on the vendor's team understands the architecture. Everyone else is filling seats.
- ▹No CI/CD — Code goes from developer laptops directly to production. No automated tests, no staging environment.
- ▹Ghost documentation — A beautifully formatted architecture document that was written at kickoff and never updated.
- ▹The demo loop — Each demo shows the same features working, but new features never quite make it to the demo.
Hour 0-8: Secure the IP
The first thing we do is secure what exists. This isn't about code quality yet — it's about making sure you actually own and control your intellectual property.
- ▹Repository audit — We verify you have access to all source code repositories. We clone everything to infrastructure you control. We've seen cases where the vendor's departure meant losing access to repos hosted on their accounts.
- ▹Infrastructure inventory — Where are your servers? Who controls the DNS? Where are the SSL certificates? Who has the cloud console credentials? We create a complete asset map.
- ▹Secrets rotation — Every API key, database password, and access token gets rotated immediately. This is non-negotiable. The old team had access to everything.
Hour 8-24: Triage
Now we assess what we're actually working with. Our senior engineers do a rapid codebase audit:
- ▹Can it build? — You'd be surprised how often the answer is "no" without some developer's specific local configuration.
- ▹Can it deploy? — Is there any automated deployment, or was it manual SSH-and-pray?
- ▹What works? — We map every feature against the original requirements and mark each one as: Working, Partially Working, Broken, or Missing.
- ▹What's dangerous? — SQL injection vulnerabilities, hardcoded credentials, unencrypted PII storage. We flag critical security issues immediately.
Hour 24-48: Stabilize
Based on the triage, we create a stabilization plan:
- ▹Set up CI/CD — If it doesn't exist (it usually doesn't), we create a basic pipeline. Build, test (even if there are zero tests), deploy to staging.
- ▹Fix the critical path — Whatever the core user journey is, we make it work end-to-end. Not perfectly, not beautifully — just reliably.
- ▹Create the test harness — We write integration tests for the critical path. This is our safety net for everything that follows.
- ▹Document what we found — A brutally honest technical assessment. No sugar-coating. The client needs to know exactly where they stand.
Hour 48-72: The Roadmap
By hour 72, we present the client with three things:
- ▹Current state assessment — What works, what doesn't, what's dangerous.
- ▹Minimum viable recovery plan — The shortest path to a demonstrable, stable product. This is usually what they need for their investor demo.
- ▹Long-term architecture recommendation — What the system should look like, and a phased plan to get there without disrupting the recovery.
The Hard Truth About Rewriting
In about 30% of rescues, the codebase is beyond saving. The architecture is so fundamentally broken that patching it would cost more than rebuilding. But here's the critical insight: you almost never need to rewrite everything at once.
We use the Strangler Fig pattern — building new services alongside the old ones, gradually routing traffic to the new code, and decommissioning the old components one by one. The product never goes dark. Users never see a regression.
Prevention Is Cheaper Than Rescue
The best rescue is the one that never happens. If you're currently working with an outsourcing partner, here's our advice:
- ▹Insist on owning all infrastructure and repository access from day one.
- ▹Have an independent technical review every quarter.
- ▹Demand working CI/CD, not just code commits.
- ▹Never let a single person become the sole knowledge holder.
And if it's already too late for prevention — we're a phone call away. We've done this before, and we'll do it again. Your IP is worth saving.