How a stuck $360,000 investment was salvaged and moved into production.

A vendor had been engaged for roughly twelve months. The venture had spent north of $360,000. Nothing had shipped. There was no working product. There was no plausible date.

The anchor customer was waiting. Client contract obligations were going unmet. The codebase was a half-finished low-code build dependent on a vendor platform the venture did not control. The contracts and licensing arrangements around that platform were unclear; nobody internally could tell us, on day one, what the venture owned, what it rented, and what it could not legally take if the vendor walked. The in-house engineering team was one person, overloaded.

That was the situation. Twelve months gone, $360,000 gone, an anchor customer waiting with contract obligations going unmet, an exhausted in-house engineer, and a codebase nobody on the inside could fully reason about.

Most teams start rebuilding on day one. We did not. The first two weeks were diagnosis, and the diagnosis was about the business, not the tech.

Four things in parallel. We talked to the business: what is the venture trying to sell, what does the anchor customer need this quarter versus eventually, where is the gap between the roadmap on the slide deck and the one or two things that would unblock revenue. We audited the inherited code end to end. We mapped the licensing, every contract with the prior vendor and every licence on the low-code platform. We figured out why the vendor had failed - not as a blame exercise, as a forensic exercise. If you do not understand the failure mode, you repeat it.

The diagnosis in plain language: the vendor had built the wrong thing the wrong way. They had treated a complex domain as a generic forms-and-workflow problem. They had locked the venture into a low-code platform that could prototype quickly but could not carry production load. And they had no engineering discipline. Twelve months of slipping deadlines was the natural result.

The strategic call we made was deliberately ugly: keep the low-code version one alive while building a proper full-stack version two in parallel.

Most engineers would have killed version one and started clean. That would have been more elegant. It would have been wrong. The anchor customer needed something shipping now. The $360,000 of sunk cost had at least produced something - a partial version one that could be patched into a usable state for a narrow first use case while we built the durable thing behind it.

One head running both tracks meant the decisions stayed coherent. What we learned shipping version one fed directly into the version two design. No telephone-game between two teams.

Underneath the two tracks we built what we call a software factory. Same operating model we now run at Civic Voice. The point of a factory is predictable throughput. Every cycle ships. No bespoke heroics, no rescue weekends, no late-night saves. If a cycle does not ship, something is wrong with the process, not with the people.

We did not replace the in-house engineer; we gave them leverage. The factory is owned by the venture, documented by the venture, operable by the venture's own people. We are leverage, not a dependency.

A year in:

Version one stabilised. The anchor customer is using it for the workflow it needed to be using it for.

Version two, the full-stack rebuild, is built and in production. The venture owns the code, the data, and the deployment.

Internal tools live and in daily use. Admin consoles, reporting, onboarding flows for new customer organisations.

New tooling now ships on a regular cadence, not as one-off projects. The factory produces.

The venture is meeting client contract obligations it had been missing. Strategy plus software factory turned client risk into client wins.

Our engagement is roughly half-time. The venture's output is full-time. That ratio is the whole point.

The common thread is not a methodology we invented. It is strategy and execution in one head: the strategic call and the build that follows it stay aligned because the same people make both. Most consultants do strategy. Most engineers do execution. We do both, and we leave behind a factory the business owns rather than a project that ends.

In the kinds of situations we are called into, neither one alone is enough.