# Graph Databases: Storing Connections as Edges You Can Follow

> A graph database stores things and the links between them, so questions about connections are fast to ask. Learn the model, the good fits, and the poor fits.

**In short:** A graph database stores things as nodes and the links between them as edges, so questions about connections, like friends of friends, are fast to ask.

From "System design", a free course by Venkat R. Murty: https://designervenkat.online/learn/system-design/graph-databases

## What you will learn

Most systems begin by storing records in tables. Some data, though, is mostly about how things connect. Who follows whom, which shop a buyer visited, and which account sent money to which other account are all links. A graph database is a database built around those links. It is a type of NoSQL database. By the end of this lesson you will know the graph model, why walking links can be quick, a worked example, and when a graph is the wrong choice.

- **Graph database:** A database that stores things and the links between them as its main shape.
- **Node:** One thing you store, such as a person, a product, or an account.
- **Edge:** A link between two nodes, such as 'follows' or 'bought'.
- **Property:** A small named fact attached to a node or an edge, stored as a key and a value.
- **Label:** A tag that groups nodes of one kind, such as Person.
- **Hop:** One step along an edge, from one node to the next node.
- **Traversal:** Walking through a graph by following edges from node to node.
- **Join:** A step in SQL that matches rows from two tables using a shared value.
- **Relational database:** A database that keeps data in tables made of rows and columns.
- **NoSQL:** A family of database types that do not all store data in fixed-column tables.

## What is the graph data model?

A graph database keeps data in three parts. Nodes are the things. Edges are the relationships between them. Properties are the details that describe a node or an edge. SAP calls properties key-value pairs, which means each detail has a name and a value.

- **Nodes:** Each node stands for one thing, such as a person, a movie, a city, or a bank account. Think of a node as a noun.
- **Edges:** Each edge joins two nodes and names the relationship, such as FOLLOWS or PURCHASED. An edge can point one way, like a follow, or work both ways, like a friendship.
- **Properties:** Both nodes and edges can carry properties. A person node might hold a name and a city. A FOLLOWS edge might hold the date the follow began.

Labels help too. A label groups nodes of one kind, so a query can ask only for People and skip Products. Labels do not change the shape of the graph. They only sort the nodes.

### How does a graph compare with tables and documents?

The easiest way to see the graph idea is to compare it with the models you may already know. Each model keeps the same facts in a different shape, and the shape decides which questions are easy.

- **Tables and rows:** A relational database stores each kind of item in its own table. A link between two tables is just a shared key, such as a customer ID in an orders table. To find the link, the database must join the tables when you ask.
- **Documents:** A document store keeps one whole record in one flexible file. This works well when one record holds almost everything about one item, such as a product with all its details.
- **Key-value pairs:** A key-value store maps one key to one value. It is fast when you know the key, but it does not describe links between items.

> **Tip:** The main difference is where the connection lives. In a table design, the link is worked out at question time. In a graph, the link is stored as an edge and is ready to follow.

## Why are traversals fast?

Take a common question: who are the friends of my friends? In a table design, you start with your ID, find your friend rows, then join the friends table again to find their friends. Each extra hop is another join, and each join builds a larger temporary result. A graph database avoids this by storing links directly.

The second part of the answer is the traversal. Two ideas make it quick. First, the database starts at one node and only looks at the edges attached to it. Second, it does not scan the whole data set at each step. The steps below show the work.

1. **Start at one node:** Find your own node. This is a direct lookup of one item.
2. **Follow the first hop:** Move along every edge from your node to your direct connections.
3. **Follow the second hop:** From each connection, move along their edges. Skip yourself and anyone you already know.
4. **Count what you found:** Each person reached is a candidate. Count how many paths led to each one.

Treat that as a claim about the design, not a promise for every product.

> **Tip:** Graphs help most when a query walks several hops. A one-hop lookup, such as one user's profile by ID, can be just as fast in a table, so do not expect a graph to win every query.

## Worked example: People You May Know

Social networks were early users of graph databases. A feature called 'People you may know' is a clear example. The model below is simplified. It is not how LinkedIn builds its feature. It shows the idea: start from you, walk two hops along connection edges, and rank people by how many paths lead to them.

### The sample network

Five people are stored as nodes: Ana, Ben, Cara, Dev, and Eli. Ana is you. Ana is connected to Ben and Cara. Ben is connected to Dev and Eli. Cara is connected to Dev. Connections go both ways, so each edge is stored in both directions. Ana already knows Ben and Cara, so she should not be suggested to herself or to them.

### Steps the database takes

1. **Start at Ana:** Ana's node is the starting point. Her direct connections are Ben and Cara.
2. **Hop one:** Move along each edge from Ana. You reach Ben and Cara.
3. **Hop two:** From Ben, you reach Dev and Eli. From Cara, you reach Dev again. Ana also appears, but she is you, so skip her.
4. **Count the paths:** Dev is reached by two paths, one through Ben and one through Cara. Eli is reached by one path, through Ben.
5. **Suggest the best matches:** Suggest Dev first, because two of your connections also know Dev.

```python
knows = {
    'Ana': ['Ben', 'Cara'],
    'Ben': ['Ana', 'Dev', 'Eli'],
    'Cara': ['Ana', 'Dev'],
    'Dev': ['Ben', 'Cara'],
    'Eli': ['Ben'],
}

def suggestions(person):
    direct = set(knows[person])
    counts = {}
    for friend in knows[person]:
        for friend_of_friend in knows[friend]:
            if friend_of_friend != person and friend_of_friend not in direct:
                counts[friend_of_friend] = counts.get(friend_of_friend, 0) + 1
    return counts

for name, paths in sorted(suggestions('Ana').items()):
    print(name, paths)

```

Output:

```text
Dev 2
Eli 1

```

The sample above uses a plain Python dictionary as a tiny stand-in for a graph. It is not a graph database. Still, it shows the walk: each hop follows the lists attached to a node, with no table join.

In SQL, the same answer needs a self-join on a large connections table. A self-join matches a table against itself, once for each hop. Each hop needs its own join against the connections table. A graph database avoids this because each node already points to its neighbors. Real products add more signals, but the core pattern stays the same: start at a node, walk edges, and count what you reach.

## When should you choose a graph database?

Choose a graph database when the connections are the point of the question, not a small detail. A good test is to ask whether the answer depends on links that run several steps deep.

- **Social networks:** Friends, followers, and group members form a web of links. Users often ask about their wider circle, which is a multi-hop question.
- **Recommendations:** Shows, products, or songs can be suggested by following what viewers or buyers with similar tastes chose. Cognee notes that streaming and shopping services use this pattern.
- **Fraud detection:** Accounts, cards, devices, and transactions can be linked as one network. Suspicious rings often show up as unusual paths between them.
- **Routing:** Places can be nodes and roads can be edges. Google Cloud notes that analysing locations and routes can help cut travel times and costs.

### When should you avoid one?

A graph is not a faster version of every database. Some jobs are a poor match, and picking a graph for them adds cost without benefit.

- **Simple lookups:** If you only need one record by its ID, a table or a key-value store is simpler. A graph adds nothing when there are no links to walk.
- **Heavy totals:** Adding up millions of records, or counting across the whole data set, is a job that tables handle well.
- **Very large data that is hard to split:** Sharding methods get their own lesson.

> **Tip:** Use a quick test. If the same question would need several joins in SQL, a graph may fit. If the question is one total over everything, a table will probably fit better.

## Check yourself

Try these two short scenarios. Each one needs the idea from this lesson.

**Quick check:** A streaming app wants to recommend shows. It looks for what viewers who watched the same shows as you also watched, three steps away in the chain of viewers and shows. Which store fits, and why?

A. A key-value store, because each show can be fetched quickly by its key
B. A graph database, because the question follows links through viewers and shows several hops deep
C. A relational table with one row per viewer, because tables always handle recommendations best
D. A document store, because each viewer's watch history fits in one document

**Answer:** B. The question is multi-hop. A key-value store returns one value for one key, so the app would make many separate calls and do the walking in its own code. A graph stores the links as edges and follows them directly.

**Quick check:** A bank needs a monthly report that adds up the amounts of 20 million card payments and groups the totals by shop type. Which choice fits best?

A. A graph database, because payments link cards to shops
B. A key-value store, with one key for each payment
C. A relational database or another store built for totals, because the question sums many records instead of walking links
D. A graph database, because fraud teams often use graphs

**Answer:** C. This question adds up many records. It does not follow a chain of links, so the graph's main strength does not help. Tables and totals are the better fit here.

## Key ideas to remember

A graph database stores nodes, edges, and properties. Its main strength is following links, such as friends of friends, without building large joins. Choose it for social networks, recommendations, fraud detection, and routing, where connections drive the question. Avoid it for simple lookups, heavy totals, and very large data that is hard to split. Keep the test in mind: if the question is about how things connect several steps deep, a graph is worth a look.

## Sources

- [Redis, Graph Database (glossary)](https://redis.io/glossary/graph-database/)
- [SAP, What is a graph database?](https://www.sap.com/resources/graph-database)
- [Google Cloud, What is a graph database?](https://cloud.google.com/discover/what-is-a-graph-database)
- [Cognee, Graph Databases Explained: Better Way to Represent Connections](https://www.cognee.ai/blog/fundamentals/graph-databases-explained)
- [HelixDB Docs, Graph vs relational database](https://docs.helix-db.com/learn/graph-databases/graph-vs-relational-database)
- [DataWalk, Relational Databases vs. Graph Databases: What's the Difference?](https://datawalk.com/relational-vs-graph-databases-difference/)
- [TigerGraph, Graph Database vs Relational Database: When to Switch](https://www.tigergraph.com/blog/graph-database-vs-relational-database/)
- [Puppygraph, Distributed Graph Database: The Ultimate Guide](https://www.puppygraph.com/blog/distributed-graph-database)
- [Partitioning Graph Databases (arXiv 1301.5121)](https://arxiv.org/pdf/1301.5121)
- [Hybrid System for Geoanalysis: Relational and Graph Databases (MDPI)](https://www.mdpi.com/2673-4591/125/1/18)
- [Understanding Graph Databases: A Comprehensive Tutorial and Survey (arXiv 2411.09999)](https://arxiv.org/pdf/2411.09999)
