How to finish a stalled app or Arduino project
What to gather, how a rescue works, and how to decide whether to fix it or start again.
Plenty of good ideas end up in a drawer half-finished. An app a developer started and then disappeared from. An Arduino project that worked on the bench but not in the shed. A prototype that's 80% there, where the last 20% turned out to be the hard part.
The good news is that a stalled project is rarely wasted. The work already done usually answers questions you'd otherwise pay to answer again. This guide covers why projects stall, what to gather before handing yours over, and how to decide whether to rescue it or rebuild it.
Why projects stall
In my experience, it's almost always one of these:
- The developer left. A freelancer moved on, an agency closed, or a mate who was helping ran out of time.
- It hit a skill boundary. The app side works but the hardware doesn't, or the reverse. Projects that mix electronics and software stall here a lot.
- The last 20% is the hard 20%. Reliability, error handling, power, enclosures and app store approval take longer than the exciting first demo.
- The real environment broke it. Wi-Fi doesn't reach, water gets in, heat resets the board, a sensor drifts.
- The scope grew. New features kept getting added until nothing was ever finished.
Knowing which one applies matters, because it decides what the fix looks like.
What to gather before handing it over
The more of this you can find, the faster and cheaper the rescue. Don't worry if some of it is missing. Just gather what you can.
Rescue checklist
For apps and software
- the source code, ideally the full repository (for example on GitHub or GitLab), not just a zip of the latest files
- logins for every account involved: hosting, domain, database, app store developer accounts, cloud services and any paid APIs
- who owns each account, and whose name and card it's in
- any design files, screenshots or notes about how it's meant to work
- a list of what works, what doesn't, and what was never started
For Arduino, electronics and hardware
- the code (the .ino files or project folder) and the board type it runs on
- clear photos of the wiring from several angles, before anything is unplugged
- a parts list, or the shopping cart and order history
- any wiring diagrams, sketches or CAD files for enclosures
- a description of where it's meant to be installed and what happens when it fails
If a previous developer is still contactable, ask them for the code and account access now, while it's easy. It's much harder to get months later.
Who owns the code and the accounts?
This is the part people often discover too late. If the app store account, the hosting or the code repository is in the previous developer's name, you may not actually control your own project. Before anything else, check that:
- the domain is registered in your name or your business's name
- the Apple and Google developer accounts are yours, or the app can be transferred
- you have full admin access to hosting, databases and cloud services
- you have the full source code, and your agreement says you own it
When I finish a project, the code, design files and accounts are handed over in the client's name. If the project runs on one of my reusable tools, that part is licensed to you, and the quote says so up front. That should be the standard for any project you pay for.
Audit first, then decide
I don't start a rescue by writing code. I start by working out what's actually there. An audit usually covers:
- Get it running. Build the app or flash the board and see what really happens, as opposed to what's meant to happen.
- Review the code and wiring. Is it structured well enough to build on, or held together with tape?
- Find the blockers. The specific problems stopping it from being finished.
- Check it against the goal. Sometimes a project stalled because it was heading in the wrong direction.
- Recommend rescue or rebuild, with a fixed price for either.
Rescue or rebuild?
Starting again feels wasteful, but sometimes it's genuinely cheaper. Here's how I usually think about it:
| Rescue it when… | Rebuild it when… |
|---|---|
| The core works and the problems are specific and fixable | Fixing one thing keeps breaking three others |
| The code is reasonably organised, even if unfinished | There's no source code, only a compiled app or a board with no code |
| The parts and platform are still supported | It's built on outdated tools, discontinued boards or abandoned libraries |
| The original approach still suits the goal | The goal has changed and the old design doesn't fit |
Even a rebuild isn't starting from zero. The old version shows what works, what users liked and where the traps are. That knowledge is worth a lot, and it makes the second build faster.
The usual fixes for hardware projects
Arduino and maker projects that stall tend to have the same handful of problems once they leave the bench:
- Power. Brownouts, wrong supplies, batteries that don't last, or no protection from voltage spikes.
- Connections. Breadboards and jumper wires that work on a desk but shake loose in the real world.
- Environment. No proper enclosure, so dust, moisture or heat gets in.
- Connectivity. Wi-Fi that drops out, with no way to reconnect or report the fault.
- Code that never recovers. One error and the device sits frozen until someone unplugs it.
Moving to a properly wired board, a CAD-designed enclosure and code that recovers from faults gets a lot of these projects over the line. I've done the same on my own builds: the Aura Discovery Booth's electronics went into custom-designed, 3D-printed enclosures with vents and proper mounting, rather than staying on a bench.
What a rescue usually costs
My stalled project rescue is $1,100 to $3,300 including GST. Where a job lands in that range depends on how much is missing, how tidy the existing work is, and whether hardware and software both need attention. I quote it as a fixed price once I've seen what's there, so you know the cost before any work starts.
If the audit shows the project has grown into something bigger, such as a full product with custom electronics, apps and a cloud backend, I'll say so and quote it as a staged build instead. Either way, you'll get a straight answer about the cheapest way to get it working, even if that answer is "don't finish this version".
Common questions
Can someone finish an app another developer started?
Yes, usually, as long as you have the source code and access to the accounts. A good developer will audit the existing code first and give you a fixed price to finish it or an honest recommendation to rebuild.
What do I need to hand over for a project rescue?
Gather the full source code, logins for every account (hosting, domain, app stores, cloud services), and for hardware, the code, board type, wiring photos and parts list. Whatever you can find helps, even if some of it is missing.
Is it cheaper to fix a stalled project or start again?
Fixing is usually cheaper when the core works and the problems are specific. Rebuilding can be cheaper when there's no source code, the parts are outdated, or every fix breaks something else.
How much does it cost to rescue a stalled project?
At Wayward Vector, rescuing a stalled app, prototype or Arduino project typically costs $1,100 to $3,300 including GST, quoted as a fixed price after an initial look at what's there.
Got a project stuck in a drawer?
I rescue half-built apps, prototypes and Arduino projects from Tamborine Mountain for clients across South East Queensland. Stalled project rescue is $1,100 to $3,300 including GST, quoted as a fixed price once I've seen what's there.
Get a fixed quote