The Technical System is not the Capability

Why better capability mapping starts by asking what your tools, services, and channels actually enable people to do.

A common moment in a User Needs Mapping session is when the conversation reaches the capabilities section, and the sticky notes suddenly start to look very technical.

  • Mobile app

  • Website

  • Payment service

  • API tool

At first glance, this can feel like progress. The group has moved beyond users and needs, and they are starting to describe the things that support value delivery. But there is an important distinction: a technical system is not the same thing as a capability.

A technical system is part of how a capability is delivered, while a capability is what the organisation, team, or system is able to do.

The distinction might sound subtle, but it changes the quality of the conversation.

A Recent Example

I was recently reviewing a User Needs Map created by someone working with a public administration payment platform. The platform is used by people to make payments to government services, as well as by internal teams and providers who need to configure, issue, manage, and reconcile those payments.

The facilitator had started in a good place. They had identified users, captured needs and started mapping the things that enabled those needs to be met.

But the first “capabilities” captured on the map were things like those in the list above. All real and important things that should absolutely be part of the conversation, but they are not capabilities. Some are channels, some are technical systems, some are integration points.

The more useful question is: What do these things enable someone to do?

The user does not need “the mobile app”. They may need to pay a fee, understand what they owe, choose a suitable payment method, receive confirmation, or access proof of payment.

The internal user does not need “the API tool”. They may need to configure a new payment flow, issue a payment notice, activate an integration, or monitor whether payments are being processed correctly.

The mobile app and the API tool may both support parts of the same underlying capability. Similarly, a single large system may contain several distinct capabilities. Those are the insights we lose when we map systems as capabilities.

Capabilities are ‘Doing Things’

When I facilitate User Needs Mapping, I often encourage people to describe capabilities in terms of verb phrases. Not because every capability name must be grammatically perfect, but because verb phrases force us to look for the behaviour the capability enables.

“Payment service” might become:

  • Process payments

  • Validate payment requests

  • Confirm payment completion

  • Reconcile payment status.

“API tool” might become:

  • Configure payment integrations

  • Activate payment flows

  • Manage provider access

  • Generate payment notices.

The system name tells us what exists; the capability name tells us what it makes possible. And that is where the map's value begins to emerge.

Why This Matters

When we conflate technical systems with capabilities, the map often reinforces the organisation's current shape.

If one team owns the mobile app, one team owns the website, one team owns the API tool, and one team owns the payment service, then any user need that cuts across those systems becomes a coordination problem.

A small change to how users pay a particular fee might require changes in several places. Each team changes “their” system, but no team is necessarily stewarding the end-to-end capability.

That is how inconsistent delivery emerges, because ownership is sliced through the technology rather than through the behaviour that creates value.

A capability lens helps us see something different:

  • Which behaviours are repeated across channels?

  • Which systems contain several unrelated capabilities?

  • Which capabilities are hidden inside legacy systems?

  • Which teams need to change together?

  • Where is stewardship unclear?

  • Where might a better team boundary reduce cognitive load?

This is especially important in legacy environments. A monolithic system is rarely one capability. It may support payment calculation, customer communication, provider configuration, reconciliation, reporting, audit, and exception handling.

If we map the monolith as a single thing, we hide that variety; if we identify the capabilities within it, we start to see potential seams.

Not because we want to break everything apart immediately, but because we want to understand the options available to us.

A Practical Way to Separate Capabilities From Systems

When a group starts capturing technical systems instead of capabilities, I would not stop them too quickly. The names of systems are often the language people already have. They are familiar, concrete, and useful. Instead, capture them, then add another layer of thinking.

1. Capture what people say

Let people name the things they know.

  • Mobile app

  • Website

  • Payment service

  • API tool

  • Provider gateway.

This gives you a useful view of how people currently understand the landscape.

2. Ask what each thing enables

For each system or component, ask:

What does this enable someone to do?

Push for verb-based descriptions.

  • Not “API tool”, but “Configure payment integrations”.

  • Not “website”, but “Allow citizens to pay online”.

  • Not “payment service”, but “Process payment transactions”.

This starts to reveal the capabilities hidden inside the systems.

3. Look for repeated behaviour

Once you have verb-phrased capability names, ask:

Where else does this behaviour appear?

You may find that the mobile app and website both enable the same user-facing capability. You may find that two internal tools both configure parts of the same payment flow. You may find that different teams maintain similar behaviour in different systems.

This is where the map starts to expose duplication, fragmentation, and potential platform opportunities.

4. Keep systems visible, but separate

Technical systems still matter. The point is not to remove them from the map. The point is to avoid mistaking them for the capability.

A useful pattern is to show the capability as the primary sticky note, then annotate the technical systems that currently enable it.

For example:

Capability: Process public administration payments Enabled by: Payment service, provider gateway, banking integration

Capability: Present payment options to users Enabled by: Mobile app, website

Capability: Configure payment notices Enabled by: API tool, fee manager

This gives you two useful views at once:

What the organisation needs to be good at and how that capability is currently implemented.

5. Overlay team stewardship

Once the capability is named clearly, ask:

  • Who stewards this capability today?

  • Who changes the systems that enable it?

  • Who is accountable for its health and evolution?

  • Who has to be involved when it changes?

This is often where the real structural insight appears. A team may “own” the website but not own any meaningful end-to-end capability. Another team may be involved in several capabilities but steward none of them. A third team may be carrying too much cognitive load because a single technical system encompasses several unrelated capabilities.

The map helps make these tensions discussable.

A Simple Test for Capability Names

When reviewing your map, try these five tests.

The verb-phrase test

Does the name describe something the organisation, team, or system can do? “Mobile app” fails this test; “Present payment options” passes it

The substitution test

Could you replace the underlying technology and still need the capability? You might replace a payment provider, but you still need to process payments. That suggests “process payments” is the capability and the named tool is the technical system.

The repetition test

Does the same system name appear in several places on the map? That may be a signal that you are duplicating a technical system rather than connecting to the same underlying component, or naming the capabilities it enables.

The change-together test

When this capability changes, do the surrounding behaviours usually need to change with it? If several behaviours always change together, they may be part of a cohesive capability. If they change for different reasons, serve different users, and require different expertise, you may be looking at several capabilities hidden within a single system.

The stewardship test

Could a team reasonably steward this capability end-to-end? Not necessarily own every line of code in every channel, but steward the behaviour, understand its users, make good decisions about its evolution, and collaborate through clear interfaces where needed.

If the answer is no, the capability may be too broad, too vague, or still too closely tied to a technical system.

What This Reveals About Team Boundaries

Capabilities are one way we reason about team boundaries. If a team owns “the mobile app”, that team may end up carrying a very broad set of responsibilities. It may need to understand tax payments, licences, permits, fines, user communication, accessibility, authentication, receipts, notifications, and support journeys. That is a lot of cognitive load.

But if a team stewards a capability such as “Enable citizens to pay tax obligations”, that team does not necessarily need to own the whole mobile app. It may need a clear way to contribute to the mobile app, website, and other channels. It may need shared design standards, a modular front-end architecture, platform support, or clear interaction modes with the teams stewarding those channels.

The question becomes:

How do we make it easy for the team closest to the capability to safely change the systems through which that capability is delivered?

That is a much better design conversation than simply asking who owns the mobile app. It connects product, architecture, and team design.

Try This in Your Next Mapping Session

Take one user need from your current map and map the value chain beneath it.

Ask:

What does the user need to be able to do? What capability enables that? What technical system currently provides it? Where else does the same capability appear? Who stewards it today? Who has to be involved when it changes? Could a team reasonably steward it end-to-end?

Then review the sticky notes.

Mark anything that is a technical system. Rewrite system names as capabilities where useful. Merge duplicates when the same system or capability appears more than once. Annotate the systems that currently enable each capability. Overlay the teams involved.

You will usually learn more from this clean-up than from the first pass of mapping. The first pass captures the current mental model; the second pass starts to reveal how the system actually behaves.

The Aim is not Perfect Mapping

The aim is not to produce perfect capability names in the first workshop. In the example I mentioned earlier, the facilitator later reflected that simply starting with verb-phrases had been a significant step forward for the team. The map helped them see that the payment service was used across the mobile app, website, fee manager, and provider gateway. It also revealed that an API tool was effectively being managed by different teams depending on the scenario.

That was useful progress; it gave the group a better way to discuss how teams could move toward clearer business domains and better-defined stream-aligned teams.

That is often what a good UNM session does. It does not produce the answer; it improves the conversation and makes the next conversation more informed.

A Note About the Flow Decision Diagnostic

This is also why I’ve recently started offering a Flow Decision Diagnostic for teams who are facing a live decision about where work is getting stuck and what might need to change.

The diagnostic is a focused way to explore that decision: what you’re seeing, what it might mean, what options are available, and what the available evidence supports doing next.

I’m inviting a small number of people to bring a real scenario into a 20-minute conversation and see whether the diagnostic would be useful. https://fastflowtoolkit.com/diagnostic


Previous
Previous

What Actually Flows Through a Value Stream?

Next
Next

When AI Learning Stays Personal