Million-Dollar Offshore Rescue

The High Cost of a Low-Cost Strategy

AI startup

Running a business is hard. Starting a business is harder.

This is especially true for a tech startup. Often, founders begin with little more than a strong idea. No users, no money, no team. No company culture. No team norms. Seemingly endless choices of technology and features. And taking the wrong step could cost everything.

One such fledgling company, an ambitious AI startup, came to Industrial Logic for help with taking their next step. In a matter of weeks, we built a high-quality production release for them that began to serve their first customers and bring in revenue.

Background

Unfortunately, this wasn't the company's first attempt at developing the application they hoped would disrupt their industry. They hired Industrial Logic only after having invested over a year (and more than $1M) in the project. Despite this significant investment, the resulting product was unusable. Its core functionality was rife with defects. In some cases, users even struggled to sign in.

They had hired low-cost, inexperienced developers to build their revolutionary product. And now they were paying the real price.

Their story is all too common; many software organizations have made (and are still making) a similar error. The company's decision to hire an offshore "budget" development team ultimately resulted in poor quality and a codebase that was not salvageable. Faced with this dire situation, they turned to us for help.

What followed was transformative. Our quick work rescued their company and set them on a path to continuous revenue growth and market leadership.

Challenges

Here's what we were up against.

benefit

The existing application was full of defects. Even when it worked, it wasn't an experience customers would be happy to pay for or recommend.

benefit

Our client had already invested over one million dollars and a year of development with minimal revenue or customers to show for it.

benefit

Our client was skeptical about the prospect of starting over, given the previous failures and sunk costs.

benefit

The company needed a functional product quickly to obtain market confidence and start generating revenue.

Solutions

Here's what we did about that.

Starting Over

waste_small.png

It’s not something we typically suggest. We are well-practiced in ways to smoothly remediate poor-quality fragile code that resists change.

But given the constraints of bootstrapping and the condition of the codebase, we proposed a way forward for the product was to rewrite the app from scratch.

The company faced this harrowing choice bravely, and we quickly got to work.

Continuous Delivery

continuous delivery.png

We aimed for rapid delivery, ensuring short intervals between idea and working software in production, promoting quick iterations and constant feedback. This approach demands creativity to identify workable slices, strong engineering to implement changes safely, and curiosity to measure outcomes. Our hands-on player coaches embodied these qualities, facilitating continuous value delivery with every change shipped to production.

Continuous Demoing

coaching_small.png

Long demo meetings are wasteful, especially when busy stakeholders cannot attend regularly. And the meetings would have been long–we were shipping new changes nearly every day!

Instead, we created a quick, simple demo video for each change we deployed to production. Sharing each video with the rest of the company broadcast a steady rhythm of progress, and gave stakeholders (who weren’t with us every day) a chance to weigh in asynchronously, on their schedule.

Data Transparency

metrics.png

We built and automated a dashboard showing real-time business metrics from the system, including the flow of customers, usage, expenses, billing, internal tools and revenue.

This made key information visible to the team. It allowed our client to steer product development on a dime, focusing improvements on the features customers were using the most. And it gave insights to their support team, helping them respond to their customers’ questions and needs faster.

Trunk-Based Development

align_small.png

Rather than using the conventional approach of branching code to hide in-progress features from users, we used Feature Toggles. This gave our client the added capability to release new features gradually to subsets of their users. It allowed them to experiment in production, buffer the user experience against the steady stream of changes, and to generally reduce risk.

It also kept our engineering workflow simple, eliminating the conflicts, errors, and delays inherent in a branching and merging approach.

Ensemble Working

mobdondont_small.png

Working as an ensemble (“mobbing”) every day created collective code familiarity and ownership, improved quality, decreased cycle time, lowered WIP, made the effort resilient to individual absences, and accelerated the influence IL coaches had on the other team members.

Also, no boring meetings!

Test-Driven Development (TDD)

tdd.png

We employed TDD to keep the code focused, clear, and safe to change. Between this and the focused, one-piece flow of ensemble working, our progress was steady and predictable, and the product was practically defect-free.

Zero-Bug Policy

no bug.png

This is not to say that there were no bugs–TDD keeps defects at bay, but they can still creep in. Having this policy simply meant that when we discovered one, we didn’t file it into a backlog to be “prioritized” later. Instead, we stopped whatever else we were doing and fixed it. Every time.

The rigor of TDD and Trunk-Based Development with an Ensemble made this way of working obvious and easy.

We had a defect frequency at a fraction of industry norms, and no bug lived longer than a few hours.

Discovery Trees

polymorph_small.png

Working quickly in small slices like this could easily become inscrutable in conventional tracking tools like Jira or Azure DevOps.

We introduced the use of Discovery Trees–a simple, flexible, visual way to track the team’s progress. They made the status of our work transparent, and kept up quite nicely with the flurry of new information and decisions inherent in building quality software quickly.

Results and Benefits

In just over two months, we released a high-quality initial offering that was ready to serve the startup’s first customers. The stream of real product revenue began early and ramped up quickly.

A chart showing the growth of revenue over the first year before IL--nothing all year, then a small amount at the end.

(In the year prior to working with Industrial Logic, there had been no revenue coming in except for a relatively small amount at the end.)

A chart showing the growth of revenue over the first year with IL--25% growth month over month.
The difference in time to first sale. Before IL: 1 year, 11 days. With IL: 2 months, 7 days.
The difference in first-year revenue. Before IL: less than $5k. With IL: over $250k
a graphic showing market leadership

Market Leadership

Not only did the new version of the app bring in revenue early and often, it is setting trends in the industry. To their surprise, copycat apps have begun to appear, one even attempting to match our client’s offering right down to the screen layout!

Strong Engineering Culture

The client's engineers learned how to deliver small changes daily and maintain a high-quality software system. We instilled and honed their practice of TDD, with an eye for leaving code organized, scannable, and optimized for change.

Code Complexity was reduced by 84%.
Code Complexity was reduced by 84%.

By the Numbers

Delivery
Mean Deployment Frequency
0.67 days (1.5 times/day)
Mean Lead Time for Changes
28 minutes
Change Failure Rate
2.3%
Mean Defect Repair Time
1.2 days
Codebase
Average file size
40 lines
Microtest coverage
75%
Overall automated test coverage
93%
The difference in size of code base. Before IL: 475k LOC. With IL: 156k LOC.
A codebase one-third the size of the first version.

Summary

Our partnership with the AI tech startup is a testament to the power of extreme programming and lean software engineering. By leveraging techniques such as ensemble programming, TDD, and continuous delivery, we transformed a failing project into a thriving product. This case study not only underscores the importance of quality in development, but also highlights our commitment to Better Software Sooner.

While lower-cost options may seem appealing initially, our experience shows that investing in high-quality, experienced teams pays off significantly, and sooner than you might think.

  • Starting Over
  • Continuous Delivery
  • Continuous Demoing
  • Data Transparency
  • Trunk-Based Development
  • Ensemble Working
  • Test-Driven Development (TDD)
  • Zero-Bug Policy
  • Discovery Trees