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.


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.



An unusable product. Even when it worked, it wasn't something customers would be happy to pay for or recommend.


Lost time and money. Over one million dollars and a year of development, with minimal revenue or customers to show for it.


A client that had been burned. Our client was going to be sensitive to our work, given the previous failures and sunk costs.


An urgent need for results. To help our client recapture their market, we needed to build them a quality offering, and fast.


Starting Over


It’s not something we typically suggest. We are well-practiced in remediating fragile, low-quality code with minimal disruption to the product.

But given the constraints of bootstrapping and the condition of the codebase, we proposed to rewrite the app from scratch.

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

Continuous Delivery

continuous delivery.png

We delivered the product in tiny slices, with no more than a few days between the idea and working software in production.

This approach demanded creativity, strong engineering skill, and curiosity. Our hands-on player coaches brought all of these to bear, ensuring an always-shippable product and a constant stream of feedback from real users.

Continuous Demoing


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


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


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


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)


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


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.

Over the following year, their revenue grew by 25% month over month on average.

A chart showing the growth of revenue with Industrial Logic, a 25% month over month growth on average.

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 before IL--nothing all year, then a small amount at the end.

Time to First Sale

Our version of the app served its first paying customer 83% sooner.

Continuous Delivery

Serving customers early and often added up, boosting the startup’s revenue by 6,000%.

Market Leadership

The app set trends in the industry, with many copycats failing to match it.

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.

By the Numbers

Mean Deployment Frequency
0.67 days (1.5 times/day)
Mean Lead Time for Changes
28 minutes
Change Failure Rate
Mean Defect Repair Time
1.2 days
Average file size
40 lines
Microtest coverage
Overall automated test coverage
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.


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