I want to tell you about a Wednesday in 2023.
That Wednesday I sat in my office at INT, which I run, and watched our operations manager spend an hour and forty minutes finding out why a customer record was different in three of our systems. The CRM said one thing. The ticketing platform said another. The billing exporter said something a third party had touched six months earlier and we were still living with. The operations manager was good. The operations manager was paid a real salary to make decisions, not to reconcile addresses. The operations manager spent an hour and forty minutes on the address question and then went to lunch.
I added up the cost of that hour and forty minutes. I added it across the team. I added it across the year. I added in the half-quarter we had recently spent migrating between two help desk products that did almost the same thing. I added in the cost of the integration platform we paid every month so that nine of our tools would mostly talk to each other. I added in the cost of the side project a senior engineer was running to keep a spreadsheet that none of the tools would maintain. The number was not subtle.
That night I walked over to one of the developers and asked an honest question. How hard would it be to build the thing we actually needed.
He did the math out loud, conservatively. The answer was that it would take a real team most of a year to ship the foundation. Twice that to ship enough product on top of it to replace what we were using. Real money. Real time. Real risk. Half the room thought it was a fool’s errand. The other half thought we were already paying for it.
We started in February of 2024.
The first thing we built
The first thing we built was not a product. It was the kernel.
I cannot overstate how badly we wanted to skip that step. The pressure inside the company was to ship something visible, fast. A CRM, a document tool, anything that would justify what we had committed to. The pressure was wrong and a few of us knew it. If we shipped a product without the kernel underneath it, we would be building the thing we were trying to escape. Another tool, on another stack, integrated with the previous nine tools through the same webhook gymnastics we were trying to retire.
So we built the kernel first. Identity. The intelligence layer. The relationship graph. The brand kit registry. The audit log. The isolation model. The action bus. Each of them in the shared kernel. None of them in a product. The team got tired of asking when we would have something to demo and I got tired of saying “not yet.”
Eight months in, we had something to demo. It did almost nothing visible. It also did the only thing that mattered: it was a foundation we could put a product on without paying the integration tax.
The first product was Orbit. It took six months. The second was Foundry. It took three. The third was OS. It took three more. By the third product the pattern was clear: the more we put on top of the kernel, the cheaper each addition got. The brand kit a customer entered in Orbit appeared in Foundry without an integration. The audit log captured every operation in every product the same way. The intelligence calls all routed through the same queue.
The moment we stopped paying
The moment we stopped paying the integration tax was not the day Orbit shipped. It was the day later that quarter when one of our account managers needed a contract. The account manager went into Orbit, picked the deal, clicked through to Foundry, generated a contract, signed it in our internal portal, sent it to the customer for countersignature, and watched the signed PDF come back. The whole flow took a few minutes. Nobody copied a contact between systems. Nobody downloaded a PDF from one tool and uploaded it to another. Nobody had to remember which CRM was authoritative.
I watched the account manager finish the contract and I added up the previous-life version of the same flow. The previous-life version had taken thirty-five minutes and required four logins. The platform version had taken seven and required one. The first time we did it, the math was already five times.
I do not think of that day as the day the product was done. I think of it as the day we stopped paying the bill.
What I want to tell you, specifically
We did not build BWI® because we are visionaries. We built it because we ran the math on the coordination tax we were paying and the math hurt. The decision was not strategic. It was forced. Most of the right answers in this business have been forced answers.
We did not build it for the customer first. We built it for ourselves. The customer comes in at the point where what worked for us turned out to work for everyone else who runs the same kind of business. Software built for a customer who does not exist yet tends to assume things about that customer that turn out to be wrong. Software built for yourself, ridden hard for a year before it gets sold, has its assumptions tested by the only customer who can tell you what was wrong with them.
We did not believe we would build it cheaper or faster than the SaaS market. We did not try to. We tried to build it correctly enough that we would not have to rebuild it in five years.
We were not certain it would work. We thought we were probably right. We thought the cost was probably worth it. We thought the customer would probably value the same things we had come to value after living with the federated stack. We bet on it.
It worked for us. The platform has run our operations for a year and a half now. The CRM I used to log in to is gone. The ticketing platform is gone. The integration platform is gone. The coordination tax we were paying is gone.
That is the experience the customer is buying. It is the only experience we know how to sell, because it is the only experience we built the platform to deliver. If it works for you the way it worked for us, then we are right about something important. If it does not, we will have learned something the slides could not have told us.
Dave Linderman, INT
[Request Early Access]