← All perspectives

Perspective / Strategy & transformation

Scale-up architecture: when domain boundaries become an operating-model decision

As a business grows, shared data and informal decisions can become constraints on delivery. Use domain boundaries to examine ownership, coordination and commercial risk before deciding whether deployment architecture should change.

10 min readReviewed

Steel structural core supporting distinct floors and a new building extension.
Conceptual editorial image.

A growing business can outgrow the informal knowledge that once connected its software and operations. Decisions previously resolved by a founder may become recurring handovers between teams, systems and suppliers. The architectural response should make responsibilities clearer without introducing unnecessary distributed-system complexity. This article examines domain boundaries as an operating-model decision for scale-ups, using an illustrative commercial platform. It compares a modular monolith with separately deployable services and shows what evidence should justify separating a capability.

The executive view

  • Use domain boundaries to clarify business meaning and responsibility before changing deployment architecture.
  • Compare operational simplicity with useful independence using actual dependencies and workload needs.
  • Test service extraction and transfer founder-held knowledge into governable contracts and decisions.
01

Recognise the organisational constraint behind the technical symptom

Symptoms such as slow releases, duplicate customer data and fragile integrations can arise from several causes. The constraint may be unclear business policy, a shared database, competing priorities or dependence on one person’s knowledge. Reorganising deployment units will not automatically resolve those issues.

Map a representative change from commercial request to production operation. Record who supplies information, who decides, which systems change and where work waits. Include the operational exceptions that require a founder or long-serving colleague to intervene.

The useful scale-up question is where responsibility has become difficult to govern. A system boundary may need to change, but so may delegated authority, process ownership or the vocabulary used by different teams. Establishing that relationship helps prevent an expensive technical programme from becoming a substitute for unresolved organisational decisions. The objective is repeatable decision-making that can support growth, not a particular diagram shape.

Measure the waiting as well as the work. If a change takes ten days but only two days involve implementation, adding another developer may leave the main constraint untouched. Classify the remaining time: business clarification, approval, test-data preparation, release coordination or operational acceptance. Several technically independent components can still share one overloaded decision-maker. Conversely, one deployment can support effective teams if its interfaces and decision rights are clear.

For a scale-up, key-person dependency deserves explicit treatment. Identify the decisions that require the founder's memory and turn them into named policy ownership, examples and acceptance tests. This is not an instruction to codify every judgement immediately. Some commercial exceptions remain decisions for a person with delegated authority. The system should make that referral visible instead of silently embedding an inconsistent rule. Architecture becomes useful to growth when it helps more people make reliable decisions within a clear scope, with the difficult exceptions routed to an accountable owner.

02

Define domains through business meaning and behaviour

A domain boundary groups rules and information that have a coherent business meaning. Sales, contracts, billing, fulfilment and support can each require different views of the same organisation. A shared customer identifier may connect them without requiring a universal model containing every field and rule.

Microsoft’s domain analysis guidance describes bounded contexts and their relationships. It offers a useful method for discussing where meaning and responsibility change. The method can inform a modular application as well as a microservice architecture.

Use conversations with people who handle difficult cases. Ask what a term such as active, approved or complete means in their part of the business. Differences are not necessarily defects to eliminate. They may indicate distinct responsibilities that need an explicit contract. The architecture should preserve those distinctions where they support clear decisions and prevent accidental assumptions from crossing boundaries.

Distinguish a shared identifier from a shared aggregate. Two domains may refer to the same customer without being allowed to change the same record or interpret every field identically. A billing account could remain open after sales marks an opportunity lost, because an existing agreement still needs settlement. A universal active flag creates ambiguity where explicit local states would be clearer.

Draw the invariant that each domain must protect. Billing may need charges to match the effective agreement; fulfilment may need to provision only an approved entitlement. If a proposed split requires a synchronous conversation across several services for every update, examine whether the boundary cuts through one tightly coupled decision. Moving that conversation onto a network does not create meaningful independence. Start with a concrete workflow and its exception paths, then decide where a stable contract can carry the information needed. This keeps the boundary discussion grounded in business meaning rather than component names inherited from the current codebase.

03

Worked example: contracts, billing and fulfilment

Consider an illustrative scale-up supplying a recurring business service. Sales agrees a commercial package, the contract process establishes commitments, billing calculates charges and fulfilment enables the service. Initially, one application and a small number of people coordinate everything.

ContextDecision it ownsInformation supplied to others
SalesWhether an opportunity is qualifiedProposed customer and package
ContractWhether an agreement is effectiveAccepted obligations and effective dates
BillingWhich charge is due under the agreementCharge and payment status
FulfilmentWhether the agreed service is enabledProvisioning outcome and exceptions

The word customer appears in every context, but each context needs different behaviour. Separating those responsibilities logically can make changes more understandable. It does not yet establish that the business needs four independently operated services. Deployment is a later decision based on coupling, criticality and the organisation’s ability to operate the result.

Now introduce a difficult case: a contract amendment changes the package halfway through a billing period while fulfilment is already provisioning the original service. Decide which agreement version each action refers to, which effective time governs charging and whether the provisioning action can be cancelled. These are business rules before they are integration messages. Include version and correlation information so each domain can relate its decision to the relevant obligation.

A useful initial implementation may keep these domains inside one application while enforcing module interfaces and ownership. Developers can then test whether changes remain local before paying for separate deployment infrastructure. Record direct database access across module boundaries as a dependency to examine, rather than claiming autonomy because folders have different names. The first success measure is that the amendment can be understood, tested and recovered without undocumented intervention. If that succeeds, the organisation has improved its operating model even if its deployment diagram still shows one application.

04

Compare a modular monolith with separate services honestly

A modular monolith can preserve domain boundaries inside one deployment. It may offer simpler operation and easier local transactions, provided modules do not bypass their interfaces and directly alter each other’s data. Logical discipline remains necessary even when the deployment is simple.

Separate services can support independent release cycles, differing workloads or distinct availability requirements. They also introduce network failures, asynchronous state, additional monitoring and more complex recovery. Independence is limited if every business change still requires coordinated releases across the same components.

Evaluate the options against actual requirements. Can a domain change without changing its neighbours? Does it need a different scaling or reliability profile? Is the team able to own deployment and incidents? A scale-up should not purchase theoretical autonomy at a cost it cannot operate. Equally, retaining one deployment should be a reasoned choice rather than an excuse to leave all internal boundaries undocumented.

Price the operating increment of a service extraction. As a hypothetical example, assume it requires £35,000 of delivery work and £1,500 per month of additional monitoring, support and platform overhead. Over two years that is £71,000 before discounting and any residual value. If the expected benefit is 300 engineering hours per year at a hypothetical £80 loaded rate, the directly modelled capacity value is £48,000 over two years. That alone does not justify the extraction. A separate reliability, regulatory or commercial need might still make it worthwhile, but that need should be explicit.

These numbers are invented to illustrate the comparison, not market rates. They force the decision to confront both sides of autonomy. Fewer release dependencies may produce valuable capacity, yet the business must still staff incidents, dependency upgrades and data reconciliation. Compare the proposed service with an improved modular design, rather than with the current disorder as if distributed deployment were the only possible remedy.

05

Make shared data and integration responsibilities explicit

Shared data often becomes the point where intended boundaries collapse. Decide which context owns each material fact, how others receive it and which changes require validation by the owner. Direct access to another module’s tables can be convenient while creating hidden dependencies that make later separation difficult.

A context map should show the direction of information and the nature of the relationship. Distinguish a request to change something from notification that it has changed. Record the expected delay and what a consumer does when information is unavailable or out of date.

For the illustrative business, billing should not infer an effective contract from an opportunity stage that sales can freely change. It needs an agreed contract-state signal or authoritative query. This boundary connects technical correctness to commercial exposure: an ambiguous integration can create incorrect charges or provision a service before the business has accepted the commitment.

Specify the information contract across each boundary: authoritative producer, identifier, version, event meaning and freshness expectation. A consumer that receives an account-updated message needs to know whether it is a complete snapshot or a notice to retrieve current state. For material operations, define what happens when events arrive twice, late or out of order. Keep transport acknowledgements distinct from completed business actions.

Reconciliation should be designed with the integration. For the hypothetical scale-up, compare effective contract entitlements with provisioned services and identify mismatches requiring action. Assign ownership for resolving them; detecting a difference does not explain which side should change. Avoid informal dual writes where two systems can independently become authoritative for the same fact. If coexistence is temporary, define the migration period and exit criterion. If it is permanent, fund the operating controls it needs. These responsibilities remain necessary whether events travel inside a process, through a queue or between independent services.

06

Extract a service only when the deciding assumption is tested

If a boundary appears to justify independent deployment, test the hardest dependency before moving the whole capability. Rehearse data transfer, deployment, failure detection and recovery. Check whether the proposed separation reduces coordinated work or simply moves it into an integration layer.

The Strangler Fig pattern provides a reference for progressively replacing responsibility. For a scale-up, a bounded extraction can be useful when the existing application must continue operating. Transitional routing and synchronisation still need owners and removal conditions.

Document the decision in an architecture record. Include the business problem, alternatives, expected benefit, additional operating cost and review trigger. Avoid using team size alone as the deciding criterion. A small team may face a genuinely separate workload; a larger one may still benefit from a coherent modular application. The relevant evidence concerns behaviour, dependencies and operating capability.

A controlled extraction needs a read path, a write path and a recovery decision. Routing reads to a new service can be reversible while a new write changes data in a way the old application cannot understand. Rehearse that asymmetry before calling a traffic switch a rollback plan. Define the compatibility period, migration checkpoint and the point beyond which recovery requires data repair or a forward fix.

Set an acceptance condition for interrupted migration. For a hypothetical pricing service, stop the transfer midway, resume it and reconcile every eligible price version against the source. Exercise requests that arrive during the interruption and establish which system may accept changes. Verify that a repeated transfer does not produce duplicate effective periods or silently overwrite a newer price. Operators should be able to identify the last reconciled checkpoint and explain unresolved differences. Compare recovery effort with the existing modular deployment. If separation adds substantial incident work without improving the targeted release constraint, reconsider the extraction before extending its scope.

07

Transfer knowledge and measure whether autonomy improved

A new boundary needs an owner who understands its business rules, interfaces and service obligations. Transfer founder-held knowledge into examples, decision records and exception policies. Document both the normal journey and the cases that previously required personal intervention.

Measure whether changes became easier to govern. Useful evidence includes fewer coordinated releases, shorter waits for cross-team decisions, clearer ownership of exceptions and reliable handling of boundary failures. Pair those observations with the commercial outcomes the separation was intended to support.

The OECD’s 2026 UK SME technology adoption report provides context for considering management and skills alongside technology. The specific scale-up architecture in this article is an illustrative analysis, not a reported outcome from that research. A mature decision leaves the business with a clearer operating model and evidence about the cost of autonomy, whether the final design is one deployment or several.

Further questions

Questions this raises

Does a growing business need microservices?

Not necessarily. A modular application may support clear boundaries with simpler deployment and transactions. Separate services are justified when their independence produces sufficient value and the organisation can operate the additional complexity.

How do domain boundaries differ from team boundaries?

Domains describe coherent business meaning, rules and information. Team structures describe responsibility and communication. They should support each other, but copying the current organisation chart into software can preserve accidental dependencies rather than useful boundaries.

What should justify extracting a separate service?

Evidence of a distinct release, workload or reliability need, manageable dependencies and a team able to own operation. The decision should explain alternatives, added operating cost, expected benefit and the conditions for reviewing the choice.

References

Sources & further reading

  1. Use domain analysis to model microservices 25 February 2026 (updated)
  2. Strangler Fig pattern 2 June 2026 (updated)
  3. SME Technology Adoption in the United Kingdom 22 April 2026

Connected capabilities

Strategy & digital transformationSoftware & CRM

From thinking to doing

What could this mean
for your business?

Your next chapter

What could your
business do better?

Tell us where you want to go, what’s getting in the way, or what you need to deliver. We’ll start there.

Start a conversation

Start a conversation

Tell us what
you have in mind.

Interactive preview. Your information stays in this page and is not sent.