TL;DR: An integration exists to remove a handoff: the email, the re-keyed order, the spreadsheet someone forwards every Monday. Integration teams build that for everyone else, then run their own work on meetings, tickets and wiki pages. Lean gives both problems a precise vocabulary, and the precision matters. It separates the value an integration delivers from the waste in building it. It classifies an integration as necessary waste rather than value. And it warns that centralising integration work can simply move the waste into a queue.


Every integration starts as a conversation. Someone in finance asks someone in sales for last month's orders, someone retypes them, someone checks the totals. An integration replaces that loop with a flow nobody has to remember, and that is its whole justification: it removes waste that would otherwise sit in a business process.

The odd thing is how rarely integration teams apply the same thinking to themselves. Specifying, building and changing an integration is still mostly handoffs. A requirement passes from analyst to developer, a question waits a week for a partner's answer, a design decision lives in one person's memory. The cobbler's children have no shoes.

This article applies Lean to both sides. The first half mentions no product at all, because Lean that starts from a tool is rarely Lean. The second half shows what we built into FastHub to make the ideas operational, and where we haven't got there yet.

Two value streams, not one

Most talk about integration and waste mixes two different value streams. Separating them is the single most useful move this article makes.

The business value stream is the process the integration serves: order, delivery, invoice. Here the integration is one step among many. The question is whether it removes more waste than it costs.

The development value stream is the work that produces the integration and changes it over its life: from a business need through specification, build and deployment, then every change afterwards. Here the integration is the product. The question is whether that work is itself free of waste. (SAFe calls the same split operational and development value streams.)

Kept apart, they give two separate questions: does this integration create value, and is it built without waste? Vendors mostly talk about the second. The business cares about the first. The rest of this article takes them in that order.

Two value streams. In the business value stream (order, delivery, invoice, payment) the integration is one step. In the development value stream (plan, build and test, deploy, run) the integration is the product, and every change loops back. The business step pulls the integration into the development stream, and the running integration's events measure the business process.

The business process pulls the integration into existence. Once it runs, the business events it emits measure that same process.

An integration is necessary waste

Lean has a blunt test for value: would the customer pay for this step? No customer pays for data moving from one system to another. They pay for the delivery, the invoice that is right first time, the answer that arrives without a phone call. Moving data is transportation, and transportation is waste.

Womack and Jones named this distinction in Lean Thinking (1996). Type one muda creates no value but is unavoidable with current technology and assets. Type two muda creates no value and can be removed at once. An integration is type one muda: you minimise it, you don't celebrate it. An integration nobody needs any more is type two, and it should go.

The reframing has teeth. Sometimes the best integration is the one you don't build, because the process is redesigned until the handoff disappears. An integration that automates a broken process doesn't remove waste. It pours concrete over it.

Four questions test whether an integration still earns its place:

  1. What manual work or delay would come back if we switched it off tomorrow? If the honest answer is "nothing", it is a zombie.
  2. What happens to the business if it stops for an hour? For a day? The answer sets the right timing, delivery guarantees and level of monitoring. It also exposes overbuilding, such as a real-time integration where a nightly batch would do.
  3. Who in the business owns this flow? An integration with only a technical owner drifts away from the value stream it was built for.
  4. Does it still carry what it was built to carry? This is harder than it looks. A scheduled route that starts, finds nothing and finishes successfully looks perfectly healthy. A flow is alive only when data actually moved.

The seven wastes of integration work

For the development value stream, the most useful map is the one Mary and Tom Poppendieck drew in Implementing Lean Software Development (2006). They translated Toyota's seven manufacturing wastes into seven wastes of software work, one for one. Each has a familiar shape in integration work.

Software waste Manufacturing equivalent In integration work
Partially done work Inventory Unapproved specifications, integrations built but never deployed, branches never merged
Extra features Overproduction Zombie integrations; real-time where a nightly batch would do
Relearning Extra processing "Why does it work like this?"; the same requirement re-explained to each new person; the same fault investigated from scratch
Handoffs Transportation Specifications passed from analyst to developer; work moved between repositories and teams
Task switching Motion IDE, ticketing, wiki, logs, Kubernetes console and secrets vault, all for one change
Delays Waiting Credentials, firewall openings, the partner's API description, a partner test environment
Defects Defects Silent failures; the re-keying errors the integration was meant to remove

Three things stand out. First, the longest delays in integration work are rarely inside the team: they are waits on someone else. Second, the most expensive defect is the one nobody sees, such as an integration that quietly stopped or a flow that never finished. We argued in September that a dashboard showing green without knowing is the costliest thing an integration platform can display.

Third, there is a symmetry. Toyota's transportation is the Poppendiecks' handoffs. An integration is transportation in the business value stream, and the largest waste in building one is handoffs. It is the same waste on two levels: the cobbler's children, in Lean vocabulary.

Mura, muri and the missing standard

Lean names three kinds of deviation, not one. Muda is waste, mura is unevenness and muri is overburden. The last two explain why the seven wastes keep coming back after every clean-up.

Mura is the project rhythm. An ERP replacement brings dozens of integrations at once, then the work goes quiet for a year. Teams staff for the peak, cut corners to meet it, and lose what they learned in the trough.

Muri is the person at the centre. Knowledge of how an integration behaves at two in the morning lives in one head. Every incident, change request and "quick question" routes through that person, and they are overloaded. The concentration of knowledge is the cause; the overburden is the muri.

The missing standard is what lets both persist. When every integration has its own structure, error handling and security model, nothing learned on one carries over to the next. In Lean, standard work is not bureaucracy. It is the baseline improvement starts from, and without it there is nothing to improve. Point-to-point architecture is the classic symptom: ten systems can need up to 45 connections, each a small, unique piece of inventory.

Centralise the platform, not the queue

The obvious answer to point-to-point sprawl is a central integration team. A Lean reader sees the trap at once: a central team is a classic bottleneck where everyone waits in the same line. Centralising cuts inventory but can add delays and handoffs, trading one waste for two others.

What should be central is the platform and the standard, so that many teams can build the same way without queuing for one. And a hub on its own reduces connections, not mappings. Without a shared data model in the middle, every pair of systems still needs its own translation.

Code is not the value. The decision is.

It is tempting to say every hour spent hand-coding an integration is waste. Stated that way, the claim is easy to knock down: integrations are still code, whoever writes them.

The defensible version is narrower. The value is in the decision (what should flow, when, with what guarantees, and why) and in verifying that the running system does it. Translating an already-made decision into syntax by hand is extra processing in Toyota's original sense: more work than the outcome needs. The code it produces is inventory that has to be maintained, migrated and understood.

So the useful question is not who writes the code but whether the code traces back to a decision. When it does, "why does it work like this?" has an answer that doesn't depend on who is still around.

That leads to the hardest form of relearning: documentation that lies. A single source of truth for decisions works only if it stays true as the system changes. A wiki page written at go-live and never touched again is not a source of truth; it is a confident guess about the past. To stay trustworthy, each rule has to carry its own rationale, and changing the rule has to flag that rationale rather than let it quietly go stale.

What we built: connecting the two streams

This is where FastHub comes in. We didn't set out to build a Lean tool. But when we mapped the platform against Lean's toolbox, the match was close enough to show, and the gaps clear enough to name.

The biggest change in recent releases is that FastHub now models the business value stream, not just the development one. A business process is its own model, described in a subset of BPMN 2.0, versioned and approved before any integration is designed. The model is never executed; integrations remain the only thing that runs. That model is what ties the two streams together.

  • Pull. An integration plan is created from a task in the process model and carries its context: the steps before and after, the messages and the data flows. The business need pulls the integration, not technical opportunity. Usage parameters left unset become open questions for a person, never guesses by the AI.
  • Partially done work, made visible. Every process step shows its implementation status (planned, linked, deployed or broken), so the editor can say "2 of 5 deployed".
  • A value stream map from real data. Process instances are derived from the business events integrations already emit, without a process engine. Monitoring shows lead time per task, and late or failed instances, directly on the diagram.
  • The process as it actually runs. A model can be mined from observed events, and the source data is shown before the model is created: cases, variants and coverage. This isn't gemba, which means going to where the work happens. It is the nearest digital equivalent: looking at what happens rather than what people believe happens.
  • A flow is alive only when data moved. On the data flow map, a flow's status can rest on business events, so the scheduled route that finds nothing no longer looks healthy. A flow can have an expected cadence, and one with no evidence is drawn grey: documented, not verified. Stopping or removing an integration names the data flows that will break before anyone confirms.
  • Rationale at the level of the rule. Mapping rules, data model definitions and process elements record their source (a contact, a document, a user), their status (confirmed, assumption or open question) and the date agreed. The server stamps who recorded it, when and through which channel. When a rule changes, its rationale is flagged stale until someone confirms it again; the AI's changes are marked automatically, and the AI cannot mark a rule as confirmed.
  • The conversation that remains, structured. Not every conversation can be removed. When an integration needs a person, it raises a user action with a deadline and a named origin. The route can wait days or months for the answer and resume where it stopped, even across restarts.

Lean's toolbox, as features

Lean tool What it means In FastHub
Value stream map Lead time and waiting, step by step Process monitoring: lead time per task, late and failed instances
Pull Build only when need pulls Integration plans created from process tasks; unset parameters become open questions
Andon Signal an abnormality at once Silence monitoring; alerts on late flows, with expected completion time learned from history
Poka-yoke Make the error impossible by design An open blocking decision prevents plan approval; the AI cannot confirm a rule
Standard work The best known way, as the baseline Project template, shared parent POM and archetypes; template updates rolled out to every integration at once, and stale parent POM copies detected
Gemba (nearest digital equivalent) See where the work happens Route runs painted step by step on the diagram; process mining from observed events
Kaizen Continuous improvement Incident, resolution and fixing commit in one place; reasons for rejecting an AI proposal feed back into the next review

One limit is worth stating plainly. Mocked partner systems (WireMock, Azurite, Kafka, Artemis and others) remove waiting from development. They don't remove waiting from acceptance testing with the partner, which still runs on the partner's calendar.

Measure both streams

Womack and Jones gave Lean five principles: value, value stream, flow, pull and perfection. The first two are about seeing, the last three about changing, and measurement is where one turns into the other. Each value stream needs its own measures.

Measure What it shows In FastHub today
Business lead time How long a business transaction takes end to end Directly: median and 95th percentile per flow type, and lead time per process task
Change lead time From need to production, and for every later change Partly: plan approval, commits and deployments are recorded, but the measure isn't computed yet
Time to explain How long it takes to answer "why does it work like this?" Partly: mean time to resolve incidents is the closest proxy
Flow efficiency Share of lead time spent on value-adding work Not yet: waiting time in development isn't recorded
Ownership Share of integrations with a named business owner By proxy: integrations linked to a process model or a verified data flow

Change lead time is also one of the DORA metrics, a familiar anchor for software teams. It matters more than how fast the first version ships. An integration lives for years, so most of its cost is in change, not in the first build.

The same principle, both ways

An integration exists to take a conversation out of a business process. The work of building integrations deserves the same treatment: decisions that carry their reasons, waiting that is visible rather than silent, and a standard many teams can build on without queuing for one.

Integration teams have spent decades removing other people's handoffs. It is time to remove our own.

References

  • Mary Poppendieck and Tom Poppendieck, Implementing Lean Software Development: From Concept to Cash. Addison-Wesley, 2006.
  • James P. Womack and Daniel T. Jones, Lean Thinking: Banish Waste and Create Wealth in Your Corporation. Simon & Schuster, 1996.

FastHub is an AI-native integration platform built in Turku, Finland — entirely from open source technologies and hosted 100% in the EU.