A freelancer stops answering emails. An agency folds. The one person who understood how everything fit together takes another job. However it happened, you're now running a business on software nobody is looking after, and there's a decent chance you don't even know where it lives.
That's a bad week. It's almost never as bad as it feels, though, and digging people out of this is a big part of what I do.
Step one: find your stuff
Before anything else, go get the keys to your own house.
You need to know where the code lives. GitHub, GitLab, a server somewhere, a folder on somebody's laptop. Ask everyone who might have touched the project, including the people you assume wouldn't know. You need control of the domain, the hosting, and any accounts the software talks to. Those are yours. You paid for them. If you can't get the logins back, reset them.
And find out what's still running. A site or app that's live is worth a lot even if nobody can change it, because it's a working example of what the software is supposed to do.
Most people own more than they think. The trick is finding all of it before anyone starts rebuilding, because paying to rebuild something you already own is the most expensive mistake available here.
Step two: get someone to read it
Once the assets are in your hands, bring in a developer to go through the code and tell you what you're actually holding. What works, and what's being held together with tape.
That assessment is the whole thing. With it you go from "we're stuck" to "here's the plan, and here's what it costs." Without it, every decision after this one is a guess. And most projects don't need to be thrown out. They need somebody to pick up where the last person put it down.
Step three: make it stable before you make it better
The instinct is to start fixing the annoying stuff immediately. Don't.
First make sure the thing isn't about to fall over. Is the hosting reliable? Are the backups actually running, and has anyone ever tried restoring one? Is there a way to put changes live that isn't a ritual only the missing developer knew?
Once that's solid, go improve things. Fix the bugs, finish the half-built features. But stability comes first, because improving a system that might fall over is just building on sand.
Move faster than feels necessary
If you take one thing from this, take this one. Get your hands on the assets now, this week.
Every day you wait, the software runs with nobody watching it. A card on file expires and the hosting lapses. A domain comes up for renewal and nobody sees the notice, because the notice goes to the developer. Backups stop running and there's nobody left to spot it. The situations that turn into real disasters are almost always the ones where somebody waited a few months to see whether the developer would come back.
They don't come back. Go get your stuff.
