A dependency arrow is not merely decoration

If Booking Service consumes Customer API, the arrow must mean something precise. It identifies the consumer and provider and a particular relationship: dependence on the API contract or runtime. The reverse statement is not equivalent.

That distinction matters when someone asks “what might break if we change Customer API?” The answer comes from finding nodes that depend on Customer API, not simply following arrows from it in whichever direction looks convenient.

Traverse providers or dependants—but say which

A provider-oriented view answers “what does this service need?” A dependant-oriented view answers “who might be affected if this changes?” These are complementary traversals over the same facts.

For a fictional chain Booking Portal → Booking Service → Customer API, the portal may be indirectly exposed to changes in Customer API. A useful tool returns both the result and the path that explains it. An unqualified label like “two hops away” tells only part of the story.

Keep relationship families separate

Not all architecture links are operational dependencies. An API has a schema, an application realises a service, a capability contributes to an outcome, and a decision justifies a choice. These should not all be traversed as though they mean “will fail if target fails.”

A query should identify which predicates it uses, whether inferred connections are allowed, what project context is included and how cycles are handled. The graph renderer can then show the resulting paths without inventing semantics.

A worked change-impact walk-through

Imagine Alderwick Services, a fictional operator with a Booking Portal that invokes a Booking Service. The Booking Service consumes a Customer Lookup API, which is provided by Customer Master. A separate Reporting Service independently calls the same API. These are four useful relationships, not just four lines on a page.

A proposed breaking change to Customer Lookup API prompts an impact query. Starting at the API, a reverse dependency traversal finds Booking Service and Reporting Service directly. Following the path another level finds Booking Portal as an indirect dependant through Booking Service. The provider itself is the changed component, not an additional dependant. If the tool followed only outbound arrows, it might misleadingly find Customer Master and report no portal risk.

Now introduce a project proposal that adds a new Billing Service consuming Customer Lookup API. A query over accepted AS-IS architecture should not include Billing Service. A combined proposal overlay should include it but clearly label it proposed. This is why the same node and edge identities require context, and why a filter can affect the correctness of the answer rather than merely its presentation.

The architect should be able to inspect the route Booking Portal → Booking Service → Customer Lookup API, see the exact predicates, and navigate to contract versions or decisions linked to that API. A colour-coded diagram without that provenance would not be sufficient evidence for a retirement decision.

Common traversal mistakes

The most common mistakes are easy to make and expensive to discover late. A generic “connected to” query can pull in governance documents and capability groupings as if they were runtime dependencies. A depth limit without a visible explanation can hide a critical indirect consumer. An inferred edge can masquerade as a confirmed integration. An edge that crosses a project boundary can incorrectly imply that proposed technology is live.

Cycles need particular attention. Two services may call one another; naïve recursion can loop indefinitely or over-count results. Visited-node tracking and path rules should be explicit. In a strongly connected group, an analysis may need to identify the group as a unit while still revealing individual services on inspection.

Finally, keep a distinction between possible impact and proven failure. An interface contract change may affect a dependant, but compatibility and usage patterns determine whether it actually breaks. A repository should guide investigation rather than automatically claim an outage.

A minimal acceptance checklist

Before releasing a dependency view, ask five questions: Can a user distinguish consumers from providers? Can they select which relationship families participate? Can they see whether a record is current or proposed? Can they inspect the path behind every impact result? Does the analysis behave sensibly with cycles and depth controls?

These tests are more useful than counting how many edges the application can draw. A small, trustworthy dependency graph is a stronger enterprise architecture asset than a large, ambiguous one.

The decision-quality test

Before trusting an impact view, ask whether an architect can inspect a returned path, confirm the direction of each relationship and remove irrelevant relationship types. If the answer is no, a colourful graph may be less reliable than a carefully maintained list.

For deeper analysis, read Architecture as a Connected Knowledge Graph.