Integration Testing Plan: How to Build One That Works

A strong integration testing plan helps teams focus on the flows, interfaces, and environments most likely to fail when separate systems meet. Here you will see how to define scope, choose an integration approach, set clear entry and exit criteria, and assign ownership so testing is controlled, repeatable, and tied to real business risk.

Hubert Olkiewicz[email protected]
LinkedIn
8 min read

An integration testing plan is the document that says how you will verify that separately built components, services and systems work together: what is in scope, which interfaces matter most, in what order you will connect things, where the tests run, who owns them and when testing starts and stops. Tricentis describes it as the blueprint for testing interactions across components, services and systems, covering scope, approach, environments, responsibilities, data and acceptance criteria. This guide walks through each of those parts in the order a team should decide them, with examples that fit enterprise systems built from several modules and third-party services.

Bitecode
Build Software Around Your Workflows
Bitecode builds tailored business software with modular components, including AI automation, financial processing, blockchain integration and workflow automation.
Visit

TL;DR

  • Start with the three to five business flows that cross system boundaries and cannot fail, then rank every interface by risk and impact.
  • Choose an incremental integration approach (top-down, bottom-up or hybrid) unless a hard constraint forces a big bang.
  • Write entry and exit criteria as measurable gates, not intentions, and enforce them.
  • Give every test case one precise expected result, a stable ID and a named owner.
  • Run the suite in CI, report trends, and update the plan whenever an interface changes.

What an integration testing plan covers

Integration testing sits between unit testing and full system or acceptance testing. IBM defines it as joining application components or modules and testing how well they work together, using test cases designed around identified integration points. The Microsoft Engineering Fundamentals Playbook adds a useful framing: these tests expose system-level problems such as broken database schemas or faulty third-party API integration, and compared with unit tests they are fewer, usually slower and more expensive to set up.

That cost profile is the reason a plan exists. You cannot test every combination of every component, so the plan decides where the effort goes. A good one answers six questions:

  1. What are we protecting (business flows, not just components)?
  2. Which interfaces carry the most risk?
  3. In what order will components be connected?
  4. What environments, data and stand-ins do we need?
  5. When may testing start, pause and finish?
  6. Who runs it, and how do results change the plan?

The sections below take these in turn.

Step 1: Define scope from business flows

The most common failure is a scope statement like “test the whole system.” Axian’s enterprise guide recommends starting with three to five business journeys you cannot afford to get wrong, and treats scope as a leadership decision about which outcomes must not break. Its examples are a revenue journey (quote, checkout, tax, payment, fulfillment, notifications), a customer lifecycle (signup, login, entitlement, billing, support access) and regulated flows such as payouts or refunds through reconciliation to reporting.

For a fintech or SaaS team, a practical scope table looks like this:

Business flow Components crossed Worst failure Priority
New customer subscription Web app, identity, billing, CRM Customer charged but no access Critical
Refund and reconciliation Payments, ledger, reporting Ledger and processor disagree Critical
Lead to account handoff Forms, CRM, notifications Lead lost silently High
Admin role changes Identity, permissions, audit log Access granted without a trace High

State what is out of scope as clearly as what is in. The IEEE 829 skeleton that Tricentis summarizes has explicit sections for features to test and features not to test, and the second list prevents arguments late in the project.

Step 2: Inventory and rank the interfaces

Once flows are chosen, map the seams inside each one. Axian advises capturing every handoff where responsibility changes: APIs, events and queues, batch files, shared data stores, ETL jobs, caches and third-party calls, then turning each seam into a contract with an owner.

For each interface, record:

  • Endpoint or channel, and version
  • Payload schema
  • Authentication method
  • Rate limits
  • Owning team or vendor

Tricentis suggests ranking interfaces by risk, customer impact, change velocity, third-party dependency and data sensitivity. Interfaces that change often and touch money or personal data go to the top of the list. Axian also recommends making identity explicit: the single sign-on handshake, token propagation, service-to-service authentication, role and permission checks, session expiry and downstream authorization behavior all deserve their own cases.

If your landscape includes several APIs, our practical guide to API integration covers the integration patterns you are likely to be testing, and the complete guide to enterprise software integration shows how those pieces fit at system level.

Step 3: Choose an integration approach

The approach is the order in which you connect components and test them. The University of Waterloo’s integration test planning notes describe planning as part of the design stage and name two basic approaches: bottom-up, where the lowest-level modules are tested first and combined into subsystems, and top-down, where top modules are tested first with stubs standing in for modules not yet written.

Tricentis adds the big bang option, where everything is joined at once, and the sandwich or hybrid style. Its advice is to aim for incremental integration unless constraints force a big bang.

Approach How it works Best when Main risk
Big bang Connect everything, then test Very small systems, hard deadlines Failures are hard to localize
Top-down Test from the top using stubs UI or orchestration layer is stable first Stubs hide real behavior
Bottom-up Test low-level modules first, using drivers Core services and data layers come first Late discovery of workflow problems
Sandwich / hybrid Work from both ends toward the middle Layered systems with parallel teams Needs more coordination

A modular system makes the incremental choice natural, because each module can be connected and verified before the next one joins. Narrow versus broad tests matter here too. Martin Fowler distinguishes narrow integration tests, which exercise only the code that talks to a separate service using test doubles, from broad ones that need live versions of all services. Most plans use many narrow tests and a small set of broad ones.

Step 4: Specify environments, data and stand-ins

The plan must say where tests run and what they run against. List the environments, how they are refreshed, which systems are real and which are simulated, and where test data comes from. For third-party systems you do not control, FrugalTesting recommends API mocking and service virtualization to simulate downstream services, plus AsyncAPI contracts for event-driven services so message schemas are checked alongside ordinary HTTP requests.

A short checklist to include:

  • Environment owner and access process
  • Data seeding and cleanup method, including masking of any production-derived data
  • Stubs, mocks and drivers, each with a note on what it does not reproduce
  • Time-dependent behavior such as batch windows, retries and token expiry
  • How a value created in one system (an order ID, a customer ID) is carried into the next

The last point is easy to overlook, and it is where many cross-system tests break. Documenting it forces the team to decide who generates identifiers and how they are passed along.

Step 5: Set entry, suspension and exit criteria

Criteria turn the plan from a description into a control. Tricentis lists entry criteria as environment ready, interfaces discoverable, data seeded and blockers cleared. Exit criteria include pass-rate thresholds, zero critical defects, stability over a set number of runs and performance baselines met. Suspension criteria say when to pause, for example during an upstream outage, and how to resume safely.

Public-sector testing standards show how formal this can get. The Florida Agency for Health Care Administration’s Testing Management Plan requires, before integration testing, an approved plan, approved scenarios, cases and scripts, test data and a ready environment. It finishes when all tests are executed, critical and major defects are resolved and validated, and results are signed off by named stakeholders. Pennsylvania’s Software Test Planning Standard goes further, asking for test cycles with break-fix-retest iterations, defect governance and thresholds, and Go/No-Go criteria.

You do not need that much ceremony for every project, but you do need the same logic. Rex Black argues that entry gates for each participating system should be documented, measured and enforced: defined unit test coverage, passing component integration tests, a defect backlog below a severity threshold and CI build-quality metrics at a set level. Admitting under-tested systems is, in his words, a false economy, because defects that belong to lower levels pollute the integration environment.

Example gates for a mid-sized project:

  • Entry: each component passes its unit and component suites in CI, no open critical defects, test data loaded, contracts for in-scope interfaces published.
  • Suspension: a dependency outage longer than an agreed window, or more than a set share of cases blocked by one defect.
  • Exit: all critical-flow cases executed, zero open critical or major defects, the suite green across several consecutive runs, sign-off recorded.

The numbers are yours to choose. What matters is that they are written down before testing starts.

Step 6: Assign ownership

Ownership is where plans quietly fail. TechTarget reports that in most organizations component integration testing falls to developers, while system integration testing, especially end to end, generally falls to testers. In Agile and DevOps teams anyone may write end-to-end tests, but developers should not test their own code. NASA’s Software Engineering Handbook likewise calls for independent personnel to perform testing.

For system integration testing, Testomat.io lists the roles: test managers or leads set scope, approach and schedule; QAs write and run cases; architects and developers support the integrated environment; business analysts confirm alignment with business requirements.

A simple responsibility matrix in the plan is enough: one named person per interface contract, one owner for each environment, one owner for the suite in CI and one person who decides whether exit criteria are met.

Step 7: Write test cases that settle themselves

A test case is useful when two people would reach the same verdict from it. BugMojo’s guidance calls for an ID, an objective, preconditions, numbered steps, specific data, one observable expected result stated precisely enough that pass or fail needs no judgment, and an actual result captured as an artifact such as a log or network trace. Drizz notes that IDs should stay stable for the life of the case and that unstated preconditions are the biggest source of tests that only work on one machine.

A worked example for the subscription flow:

  • ID: INT-BILL-012
  • Objective: a successful payment event activates the subscription.
  • Preconditions: test customer exists, plan is active, payment stub returns success.
  • Steps: submit checkout, send the payment-confirmed event, read the entitlement from the identity service.
  • Expected: entitlement status is “active” within the agreed time, and one ledger entry exists for the amount.
  • Actual: log excerpt and response payloads attached.

Cover happy paths, boundary values and negative scenarios. Tricentis recommends risk-based selection, and TotalShiftLeft suggests picking five to ten end-to-end API journeys, each with its most important error path. For teams building billing flows, our walk-through of subscription billing integration shows what such a path involves.

Step 8: Keep end-to-end tests few and meaningful

End-to-end integration testing checks a complete business flow across all connected components, while interface-level testing checks one seam at a time. FrugalTesting’s API testing pyramid puts unit tests at the base, integration tests in the middle and end-to-end tests at the top, reserved for the highest-risk paths. TotalShiftLeft notes that API-level end-to-end tests are less flaky than UI ones, since there is no rendering, selector or browser timing to contend with.

In practice:

  • Test each interface contract narrowly and often.
  • Run a small number of broad flow tests against a realistic environment.
  • Put UI-driven end-to-end checks only where a user-facing step is itself the risk.

TechTarget’s Gerie Owen adds a timing point: begin system integration testing as workflow modules are completed and component-tested, and test APIs as early as possible. Waiting for a finished system moves discovery to the most expensive moment.

Teams automating the checks themselves may also want to read about automating schema testing, since structured payload validation follows the same principle of turning contracts into repeatable tests.

Step 9: Handle defects and regression

When a case fails, the defect record needs enough context to be acted on. Jama Software lists requirement references, a severity classification and a description of actual versus expected behavior. After the fix, repeat the failed tests and rerun previously passing cases the change could have affected.

Katalon’s template guidance recommends recording actual results as they happen, marking status accurately (pass, fail or blocked) and linking the defect ID in the same row, so a sprint review can trace every failure. Its template is built as a case sheet with fields for module, preconditions, instructions, expected and actual results, status, severity and environment, plus a summary tab and a how-to tab.

Test case sheets document regression results

Step 10: Execute, report and keep the plan alive

Tricentis advises wiring the suite into CI so it runs on merges to the main branch and on nightly builds, publishing logs, traces, failing payloads and trend dashboards. After each cycle, triage quickly, record lessons learned and update risks and tests as interfaces evolve.

A plan that is never revised describes a system that no longer exists. Functionize’s strategy template suggests treating its contract and environment sections as living documents and revisiting them every quarter. Add a change trigger as well: any new version of an in-scope interface, new vendor or new data class reopens the relevant part of the plan.

Governance matters when automation drives these flows. Our IT automation governance checklist is a good companion, and the guide to testing methodology places integration testing among the other test levels.

A one-page template outline

If you need a starting skeleton, the IEEE 829 structure works well when trimmed to integration testing:

  1. Purpose and objectives
  2. Scope: flows and interfaces in and out
  3. Approach and integration order
  4. Test environments, data and stand-ins
  5. Entry, suspension and exit criteria
  6. Test case index and design rules
  7. Roles and responsibilities
  8. Schedule and milestones
  9. Risks and mitigations
  10. Defect handling and reporting
  11. Approvals and change control

One page of content under each heading is usually more useful than a sixty-page document nobody reads.

Perspective

Most integration problems we see are not caused by careless testing. They come from systems whose boundaries were never designed to be tested. When every connection is custom, each seam is a new unknown, and the plan has to cover far more ground.

This is one reason we build on a modular foundation. Our approach is designed to start projects with up to 60% of the baseline system already pre-built, so a large share of the components and the connections between them are known before the first sprint. That lets a team spend its testing effort where the business-domain complexity actually sits: the financial logic, the AI automation steps, the blockchain settlement flows and the customer-specific integrations.

A modular base also supports the incremental integration approach that testing guidance favors: connect one module, verify it, then add the next. It accelerates work without accelerating chaos, because each step has a defined contract and an owner.

Our advice to teams: write the plan at the start of design, rank interfaces by money and data sensitivity, and keep the critical-flow suite small enough to run on every merge.

Bitecode

Build the system and the test plan together

If you are planning a new enterprise platform, an internal system or a SaaS product, the cheapest time to design for testability is before the architecture is fixed. We build custom business software from modular, ready-made components, and we can scope a project with the integration points, environments and acceptance criteria defined up front.

Bitecode

For workflow-heavy projects, see our AI business process automation services, or start from the Bitecode homepage to describe your project.

FAQ

Who is responsible for integration testing?

It depends on the level. In most organizations developers own component integration tests and testers own system integration and end-to-end tests, according to TechTarget. Developers should not be the only ones testing their own code, and the plan should name an owner for each interface and environment.

Is system integration testing done before or after UAT?

System integration testing comes first. It verifies that connected systems work together technically, so that user acceptance testing can focus on whether the business flows meet requirements. Entry criteria for acceptance testing normally require integration exit criteria to be met.

What is the difference between an integration test strategy and an integration test plan?

The strategy sets the general approach: levels, integration style, automation candidates and ownership. The plan applies it to a specific project with scope, schedule, environments, data and criteria. Smaller teams often combine both in a single document.

How many end-to-end tests do we need?

Fewer than most teams expect. Guidance from Axian and TotalShiftLeft points to a handful of critical journeys, roughly three to ten, each with its main error path. Cover everything else with narrower interface and contract tests that run faster and fail more clearly.

Sources

Articles

Dive deeper into the practical steps behind adopting innovation.

Software delivery6 min

From idea to tailor-made software for your business

A step-by-step look at the process of building custom software.

AI5 min

Hosting your own AI model inside the company

Running private AI models on your own infrastructure brings tighter data & cost control.

Hi!
Let's talk about your project.

this helps us tailor the scope of the offer

Przemyslaw Szerszeniewski's photo

Przemyslaw Szerszeniewski

Bitecode co-founder

LinkedIn