Product Knowledge Graph: One Source of Truth for Product Decisions
What a product knowledge graph is, which nodes and relationships it needs, and a step-by-step method to make it the single source of truth for product decisions.
Share
A product knowledge graph stores every piece of product evidence (customer calls, feedback, tickets, metrics, decisions) as connected nodes, linked by named relationships such as "supports" or "contradicts". Unlike a wiki, it can answer "why did we build this?" by following the links from a shipped ticket back to the customer evidence. That traceability is what makes it a working single source of truth for product decisions.
Key takeaways
Teams spend over 25% of their workweek searching for information, according to Atlassian's State of Teams 2025 survey of about 12,000 knowledge workers (Atlassian, 2025).
30% of developers say knowledge silos hurt their productivity 10 or more times a week (Stack Overflow, 2024).
A knowledge graph is built from three-part statements (subject, relationship, object) that join into a network (W3C, 2014).
The graph should index evidence, not replace your tools: Jira, Gong and your analytics stay the system of record.
Start from your last 10 decisions and link backwards to their evidence. That is enough to prove the value in a week.
What is a product knowledge graph?
A product knowledge graph is a connected model of everything a team knows about its product and customers. Each item is a node with a type (a customer interview, a feature request, a decision, a ticket). Each link is a typed relationship ("this interview supports this insight", "this decision addresses this opportunity").
The idea comes from general knowledge graphs. When Google launched its Knowledge Graph in May 2012, it described the shift as "things, not strings": search would understand entities and the relationships between them rather than matching keywords. At launch it held more than 500 million objects and more than 3.5 billion facts about them (Google, 2012).
The underlying structure is simple. The W3C's RDF primer describes each statement as a triple: two things and the relationship between them. Because statements share things, the triples join into a connected graph of nodes and arcs. In product terms:
Five rows, and you can already answer who asked for this, why we chose it, what we built, and who disagreed.
Why do product teams need a single source of truth for decisions?
Product context is scattered by default. Customer evidence lives in call recordings and support tools, reasoning lives in Slack threads, and delivery lives in Jira. When someone asks why a feature exists, the answer has to be rebuilt by hand.
The cost of that rebuilding shows up in every workplace survey. Atlassian estimates that Fortune 500 teams are wasting 2.4 billion hours searching for information. Stack Overflow's 2024 survey found 61% of developers spend more than 30 minutes a day searching for answers or solutions. Asana's Anatomy of Work Index, a survey of more than 10,000 knowledge workers, found 60% of time going to "work about work", including hunting for documents (Asana).
For product teams the damage is more specific than lost time:
Decisions get re-litigated. Without the original evidence and the rejected alternatives, every new stakeholder reopens the question.
Evidence gets cherry-picked. The loudest customer quote wins because nobody can see the 20 tickets that point the other way.
Shipped work never gets checked. A ticket closed in Jira says the code shipped, not that the customer problem went away.
AI tools hallucinate context. An assistant or coding agent with no access to the real evidence fills the gap with plausible guesses.
"Single source of truth" does not mean one tool holds everything. It means one place where the connections live, so any claim can be traced to its evidence.
What goes into a product graph?
Keep the schema small. Most teams need eight to ten node types and five or six relationship types. Teresa Torres's opportunity solution tree is a useful backbone: a desired outcome at the top, customer opportunities (unmet needs, pain points and desires) below it, then solutions, then assumption tests (Product Talk, 2023). A knowledge graph adds the raw evidence underneath and the delivery work on the other side.
Node types
Node type
What it is
Typical source
Signal
Raw evidence: a call excerpt, a support ticket, a survey answer, a metric change
Gong, Zendesk, Intercom, PostHog, Slack
Insight
A synthesised finding backed by several signals
Research synthesis
Opportunity
An unmet customer need worth solving
Discovery work
Assumption
Something that must be true for a solution to work
This decision or solution targets that opportunity
Links strategy to customer need
implements
This ticket delivers that decision or spec
Links delivery to reasoning
measured by
This decision is judged by that outcome
Closes the loop
"Contradicts" is the relationship most teams skip and the one that pays for itself. A graph that only records supporting evidence is a confirmation-bias machine.
How does a knowledge graph compare with a wiki, Jira or a data warehouse?
Each tool answers a different question. The graph is the only one built to answer "why".
Wiki (Notion, Confluence)
Jira / Linear
Data warehouse
Product graph
Best at
Long-form documents
Tracking delivery
Aggregating metrics
Tracing reasons across sources
Structure
Pages and folders
Issues and fields
Tables
Typed nodes and relationships
Answers "why did we build this?"
Only if someone wrote it down and you find the page
Rarely
No
Yes, by following links
Captures disagreement
In comments, unlinked
In comments, unlinked
No
As "contradicts" relationships
Goes stale when
Nobody updates the page
Tickets close
Pipelines break
Nobody links new evidence
The graph does not replace any of them. It references them. A good rule: if a fact already has a home in another tool, the graph stores a short summary and a link, not a copy.
How do you build a knowledge graph for product decisions?
You can start with a spreadsheet or a database with relations before buying anything. The method matters more than the tool.
Pick your node and relationship types. Start with the lists above and delete what you don't need. Write a one-line definition for each.
Start from your last 10 decisions. List them, then link each one backwards to the evidence that justified it. This is faster than ingesting everything forwards, and it shows the value immediately.
Give every node a stable ID and a link to its source. The graph should point to the Gong call or Jira ticket, not paste it in.
Record alternatives and status on every decision. Michael Nygard's decision-record format marks each decision as proposed, accepted, deprecated or superseded, with its consequences (Michael Nygard, 2011). Superseded decisions stay in the graph, linked to their replacement.
Link contradicting evidence on purpose. When new evidence argues against an accepted decision, add a "contradicts" link and flag it for review.
Add an outcome node after every release. Schedule a check four to six weeks after launch and link the metric result to the decision.
Automate ingestion, keep linking reviewed. Pulling in signals can be automated; asserting that a signal supports a decision should be reviewed by a person, at least until you trust the automation.
A product decision log template is a good first step if you are not ready for a full graph: it covers step 4 on its own.
Worked example: tracing one decision (illustrative)
Say a 10-person B2B SaaS team decides in Q1 to build scheduled report exports. Six months later, a new head of sales asks why they didn't build a public API instead. Here is what the graph shows:
Node
Detail
Link to the decision
23 support tickets
Customers asking to export reports, over 60 days
derived into an insight
4 of 9 discovery interviews
Admins rebuild the same report every Monday
supports the insight
2 churned accounts
Exit notes cite manual reporting time
supports the insight
1 sales call
"Enterprise prospects want an API"
contradicts the decision
Decision
Build scheduled exports; API deferred to H2, revisit if 3+ enterprise deals stall on it
addresses the opportunity
PRD + 7 tickets
Scope, acceptance criteria, delivery
implement the decision
Outcome
Export-related tickets fell from 23 to 6 in the 60 days after release
measured by
The new head of sales gets the answer in two minutes, including the dissent and the condition for revisiting it. Without the graph, the same answer means searching Slack, finding a PRD that may be out of date, and asking whoever still remembers. The decision either holds up or gets reopened with evidence, which is the point.
How do you keep a single source of truth from going stale?
Make linking part of existing rituals. Link evidence during interview synthesis and decision reviews (such as the Thursday synthesis block in an example PM weekly schedule), not in a separate "graph maintenance" session nobody attends.
Assign an owner per decision. The person who made the call keeps its status current.
Store summaries, not copies. Copying entire tickets and transcripts creates a second warehouse that drifts. Keep a compact excerpt and a link.
Review contradictions weekly. A 15-minute look at new "contradicts" links catches decisions that need reopening.
Label demo and example data. If seeded or sample content can be mistaken for a real customer signal, the graph stops being trustworthy.
Close the loop. Every decision without an outcome node after release is an open question, not a finished one.
When is a knowledge graph overkill?
A solo founder with one product, five customers and every decision in their head does not need a graph yet. A one-page decision log will do. The graph starts paying off when more than one person makes product decisions, when evidence arrives from three or more tools, or when you hand work to AI coding agents that need context they cannot ask for.
Be honest about its limits too. A graph is only as good as its links: wrong "supports" relationships give false confidence. Automated linking makes mistakes, so treat AI-proposed links as suggestions. And customer evidence often contains personal data; store only what you need, and make sure you can delete a person's data on request.
Where does Specky fit?
Specky's Product Graph is built this way. It reads customer calls, feedback, Slack, Jira, analytics and other sources into typed nodes, keeps compact evidence with links back to the source tools, and records relationships such as supports, contradicts and derived from. When new evidence conflicts with existing evidence, AI flags it as a contradiction. PRDs cite their evidence inline, tickets stay linked to their PRD, and coding agents can read the same context over MCP. Example data is always labelled as example. See how Specky compares with other tools that connect decisions to customer evidence.
Frequently asked questions
What is the difference between a knowledge graph and a database?
A knowledge graph is a database shaped around relationships. A relational database stores rows in tables and joins them when queried; a knowledge graph stores things and named links between them as first-class data. That makes multi-step questions, such as "which customer evidence led to this ticket?", much easier to ask. Many product graphs actually run on an ordinary relational database.
Is a knowledge graph the same as a wiki?
No. A wiki stores documents; a knowledge graph stores connections between evidence, decisions and work. A wiki page can explain a decision, but it cannot show which 23 support tickets backed it or which sales call disagreed unless someone maintains those links by hand. The two work well together: the wiki holds long-form writing, the graph links it to everything else.
What should be the single source of truth for product decisions?
The single source of truth for product decisions should be a decision record linked to its evidence, alternatives, owner, status and outcome. It can live in a decision log or a product knowledge graph. It should not be Slack or meeting notes, because neither records status or links to the evidence. Delivery tools such as Jira remain the source of truth for work, not for reasons.
Do you need a graph database to build a product graph?
No. A spreadsheet with ID columns or a database with relation fields is enough to start, as long as every node has a stable ID, a type and a link to its source. Dedicated graph databases help when you run deep multi-step queries over millions of nodes. Most product teams hit organisational limits, such as who maintains the links, long before technical ones.
How do AI tools use a product graph?
AI tools use a product graph to retrieve relevant evidence before they answer or write. Instead of guessing, an assistant can pull the interviews, tickets and decisions linked to a topic and cite them. This reduces invented context in specs and tickets. It also helps coding agents, which cannot ask the PM a follow-up question mid-task.
How do you connect customer feedback to product decisions?
Connect customer feedback to product decisions by linking each piece of feedback to an insight, each insight to an opportunity, and each decision to the opportunities it addresses. Record contradicting feedback as well as supporting feedback. Then add an outcome after release. The guide to turning customer feedback into a roadmap walks through the first two steps.
GDPR-aligned. EU workspace data is stored in Frankfurt, Germany. GDPR and EU data Built in Vienna, Austria. A product of influence solutions fm GmbH (FN 675374y). Imprint 14-day trial. Card required, and nothing is charged until day 14. 30-day refund after subscribing. See pricing