How Lab0 implements enterprise software
Software doesn’t work out of the box. Someone has to set it up: understand how the company works, connect it to existing systems, and test that the setup works. That setup is called implementation.
It’s usually done by consultants, by hand, over months. Lab0 does the same work using AI agents, and it does it in weeks.
This page follows one example. A large company we’ll call Acme bought Coupa, and Lab0 is implementing it.
- Coupa
- A procurement platform. It runs how a company buys things, from purchase request to approval to purchase order. This is the software Acme just bought.
- ServiceNow
- An ITSM platform: where IT receives, routes, and approves requests and tickets. Our laptop request needs IT approval here.
- SAP
- An ERP system: the finance system of record. It holds budgets, approved vendors, company codes, and cost centers.
Acme already uses ServiceNow and SAP. Coupa is new. The job is to make them work together.
We’ll follow one workflow: an employee requests a laptop in Coupa. The request needs IT approval in ServiceNow, finance checks in SAP, and then the result has to come back to Coupa.
That sounds like changing a few settings. In practice it is a lot more. Here is the difference Lab0 makes before we get into how.
Finding out how Acme actually does this
Before connecting systems, you need to know how Acme works.
What counts as an IT purchase? Who approves it? What finance checks are required before money is spent? Which ServiceNow table receives the request? Which status means review is done? Which field should go back to Coupa?
No single person or document has the full answer. The knowledge is split across kickoff calls, docs, specs, and people’s heads.
Lab0 opens a workspace for the project and reads the kickoff transcript, requirements doc, and integration spec. It answers what it can, flags what is missing, and sends short questions to the right people.
The answers come back and become implementation records.
Looking inside the systems
ServiceNow alone has roughly 4,000 fields. About fourteen matter for this one workflow, and they are not in one place. They belong to different teams: IT owns the request and assignment fields, security owns the access rules, finance owns the cost center and company code, procurement owns the reference that goes back to Coupa.
That spread is what makes it slow. No one person knows all fourteen, so the answer usually comes out of four separate conversations.
Lab0 connects to the systems and inspects them directly. In ServiceNow it finds where laptop requests should go, who approves them, and which field is missing for Coupa’s reference number. In SAP it checks the finance details: vendor, cost center, company code, and related records.
Building the connection
The hard part is the handoff between Coupa and ServiceNow.
The systems use different words for related things. Coupa’s “requester email” might be ServiceNow’s “requested for.” Coupa’s approval status might not match ServiceNow’s ticket status. Cost center, category, requester, and decision all need to line up.
Most fields line up once they are renamed. One does not. Coupa and ServiceNow describe the approval differently, so the values have to be translated. Lab0 builds a small customization that converts each Coupa status into the matching ServiceNow status.
Then it adds the missing field, builds the connection, and runs a test request all the way through to confirm it works.
Implementation never really ends
The workflow is live. That is not the finish line.
Requirements keep moving. A new approval threshold, another system to connect, a field finance now wants on every request. In most companies each of these changes means re-learning how everything was wired, because the people who built it have moved on and the context left with them.
Lab0 keeps that context. Every new change runs against what it already knows about Acme’s setup, so adding a feature is closer to an edit than a fresh project. The second request is faster than the first, and the tenth is faster again.
The next system is an edit, not a rebuild
Coupa runs purchasing, ServiceNow runs IT, SAP runs finance. Lab0 sits alongside them and holds the layer that knows how they connect for Acme.
That layer is what lasts. Acme will keep adding software: a new ERP module, a billing tool, another approval flow. Each one has to work with what is already there.
Because Lab0 already holds how Acme’s systems fit together, the next implementation does not start from a blank page. It starts from everything the last one learned, which system owns finance, how approvals route, which fields map to which. The first project is the hard one. After that, putting in new software or changing a workflow is something Acme can do almost any time, at ease.
What this adds up to
Implementation still runs on calls, workshops, consultants, review cycles, and knowledge stuck in people’s heads. That is why it takes months.
Lab0 turns the by-hand work into software.
It learns how a company operates, finds the right pieces in each system, maps them, builds and tests the workflow, and keeps what it learned so the next change is quick.