Insight · Integration

How to Build Power BI Dashboards from Your Sparx EA Repository

The short version: Power BI can read your architecture repository directly once EA GraphLink exposes it as a GraphQL endpoint. After that, the build is a tight loop: explore the schema, point Power Query at the endpoint, write one query per table, assemble a star schema, and design the four dashboards your stakeholders actually open. The quality of those dashboards is decided long before Power BI — it is set by how disciplined your MDG Technology and tagged values already are.

This guide is for the architect or BI developer who has EA GraphLink running and wants something defensible on a screen. If GraphLink is not deployed yet, that is the real first step, and it is the part Sparx Services stands up with you through Configure the Solution — not something to improvise the night before a steering committee.

Before you start: what GraphLink actually is

One correction worth making up front, because it changes the whole design. There is no built-in MCP server inside Sparx EA core, and there is no native way for Power BI to reach the repository on its own. What makes this possible is EA GraphLink — part of Kernaro AI Hub — a read-only server you deploy that translates the physical Sparx schema into a clean GraphQL schema. GraphLink is recent (it shipped in January 2026), so most teams are connecting Power BI to it for the first time rather than maintaining a long-standing pipeline.

The translation layer is the point. GraphLink leans on the MDG Technology defined for your repository, which means your element types, tagged-value dimensions, and relationship types arrive as first-class, named GraphQL fields — not raw rows from t_object. That is what makes a Power BI model possible without hand-writing SQL against the internal Sparx tables.

The build, step by step

Six steps take you from a running endpoint to a published, refreshing dashboard set. A seventh — natural-language querying through Copilot — is optional and sits on top.

1

Read the GraphQL schema first

Before you write a single Power BI query, learn what GraphLink exposes — it shapes every later decision. Point a GraphQL client (Insomnia, Postman, or the playground if enabled) at the endpoint and run the introspection query { __schema { types { name fields { name } } } }.

Expect each ArchiMate element type and custom stereotype as its own type (ApplicationComponent, Capability, TechnologyNode, DataObject), each tagged value as a field on its stereotype, and relationships as nested objects (for example Capability.realisingApplications). Write down the query patterns each dashboard will need before you open Power BI — that one habit saves hours of rework.

2

Connect Power BI to the endpoint

Power BI has no first-party GraphQL connector, so you connect through Power Query in one of two ways: a custom/third-party GraphQL connector, or the standard Web connector posting your GraphQL query as the request body. Either route lands you in Power Query, where each query becomes a table.

Set the endpoint (https://[your-pcs-host]/eagraphlink/graphql) and authenticate with the GraphLink API key. Confirm the link with a throwaway query that pulls a handful of applicationComponents with their tagged values. A clean result set means you are connected; an error usually means the URL, key, or network path needs a look.

3

Write one query per table

Design a query for each table in your model, each retrieving one element type with the fields you need. A typical set: application components (your portfolio fact table), business capabilities, application-to-capability realisations, technology nodes with end-of-life dates, and architecture decision records.

Name each query deliberately — the query name becomes the table name in the model, and renaming later is friction you do not need. Keep field selection lean; pull only what a visual or measure will actually use.

4

Model a star schema

In Model View, wire the tables into a star: element tables as facts, tagged-value enumerations as dimensions, relationship tables joining the two. Applications join the realisation table one-to-many on element ID; that table joins capabilities many-to-one. Add deployment relationships the same way if GraphLink surfaces them.

Then add the DAX measures that carry the story: end-of-life application count, average capability maturity, and an owner-coverage percentage such as DIVIDE(CALCULATE(COUNT(Apps[id]), Apps[businessOwner] <> ""), COUNT(Apps[id])). Handle blanks explicitly — missing tagged values should read as "Unknown", not silently vanish from a chart.

The dashboard is only ever as honest as the repository behind it. A clean star schema on top of inconsistent tagged values produces a confident, well-formatted, wrong answer — which is worse than no dashboard at all.

The four dashboards worth building

Resist the urge to visualize everything. Four views cover the questions stakeholders and the EA team actually ask, and each maps to fields you already modeled.

  • Application Portfolio Heat Map — a matrix with business domain on rows, lifecycle status on columns, application counts as values, and a red-to-green color scale. The classic at-a-glance picture of where the portfolio is concentrated and aging.
  • Technology Lifecycle Timeline — technology nodes plotted against their end-of-life dates (a Gantt-style or bar visual), filtered to the next 24 months. This is the proactive remediation view: what loses vendor support, and when.
  • Capability Coverage — capabilities by domain, colored by coverage (none / partial / full) and counted against supporting applications. It surfaces the capabilities running on thin or aging application support.
  • Governance Health — owner-coverage and lifecycle-coverage percentages, average maturity by domain, and an ADR status breakdown. This one is for the EA team itself: it shows exactly where repository data quality is strong and where remediation pays off.

Keep the labels in business language, not metamodel syntax. "Application End-of-Life Risk" reads in a steering committee; "ApplicationComponent.LifecycleStatus = EOL" does not. Consistent colors across every view (red = risk, green = healthy, gray = unknown) do more for adoption than any single clever chart.

Publish, refresh, and govern access

Publish from Power BI Desktop into your workspace, then set a scheduled refresh in Power BI Service — daily is plenty for architecture data. Because GraphLink typically runs inside your network (often alongside Pro Cloud Server), the Power BI Service reaches it through an on-premises data gateway: a small Windows service that tunnels securely from the cloud to the internal endpoint, using the same API-key authentication as the desktop connection.

If different stakeholder groups should see only their own domain, apply row-level security in the model so one dataset serves everyone without leaking across boundaries. For most EA programs, Power BI Pro licensing covers this comfortably; Premium Per User or Fabric capacity only earns its place when you need very frequent refresh, large-dataset storage, or the full Copilot feature set.

Optional: natural-language querying with Copilot

For teams already licensed for Microsoft 365 Copilot, enabling Copilot on the published dataset lets stakeholders ask questions in plain language — "which domain has the lowest average capability maturity?" — instead of reading a matrix. It is a genuine adoption lever for non-technical audiences.

Be clear about what it queries, though. Copilot here reads the imported Power BI model, so its answers reflect the last refresh, not the live repository. When stakeholders need answers against the live model — current as of this moment — that is a job for GraphLink's MCP interface and a Copilot connection straight to the repository, which is a different integration entirely. The dashboard and the live MCP path are complementary, not the same pipe.

The thing that decides whether this works

None of this rescues a thin repository. The heat map, the lifecycle view, the governance scorecard — each is only as trustworthy as the tagged values feeding it. That is why the Governance Health dashboard tracks completeness as a feature, not a footnote: it points the team at the gaps, and closing those gaps is what makes every other dashboard more accurate over time. Connecting architecture data to Power BI is one concrete expression of AI Augmented Architecture — the data you already maintain, made legible to the people who need it.

If you want the endpoint, the connector, the model, and a starter dashboard set delivered as a working baseline rather than a weekend project, that is exactly the scope of Configure the Solution. For the wider picture of what live architecture data unlocks across the practice, see AI Augmented Architecture.

Want these dashboards live, not on a wishlist?

Talk to a practitioner about standing up EA GraphLink and a publish-ready Power BI dashboard set on your Sparx EA repository.

Book a call →