English for Neo4j Graph Database Developers

Graph databases reframe data modeling around relationships as first-class citizens, and Neo4j’s vocabulary — “traversal,” “relationship direction,” “Cypher pattern” — differs enough from relational thinking that teams new to it often talk past each other. This guide covers the English used when discussing Neo4j and graph data with a team.

Key Vocabulary

Node — a graph entity representing a single object (a person, a product), carrying labels and properties, roughly analogous to a row but without a fixed schema. “Don’t model this as one giant node with dozens of properties — split the address out into its own node connected by a relationship, so it can be shared and queried independently.”

Relationship — a typed, directed connection between two nodes, itself capable of carrying properties, and the primary unit graph queries traverse across. “Model ‘FOLLOWS’ as its own relationship type rather than a boolean property on the user node — that lets us query and traverse the social graph directly.”

Cypher pattern — the graph-matching syntax at the core of Cypher queries, describing nodes and relationships visually with ASCII-art-like arrows, e.g. (a)-[:KNOWS]->(b). “This Cypher pattern is matching in the wrong direction — the arrow implies A knows B, but the data actually models it the other way around.”

Traversal — the process of walking from node to node across relationships to answer a query, whose cost scales with the number of relationships visited, not total dataset size. “This traversal is unbounded — without a depth limit on the relationship pattern, a densely connected subgraph could make this query run for minutes.”

Index — a lookup structure on node or relationship properties that lets Neo4j find starting points for a traversal without scanning every node of a label. “Add an index on the email property — without it, every login query starts by scanning every single user node before it can even begin traversing.”

Anti-pattern: supernode — a node with an extremely high number of relationships (a celebrity account, a popular tag), which can make traversals through it disproportionately slow. “This tag node has half a million relationships — treat it as a supernode and avoid full traversals through it; consider a different query strategy for common tags.”

Common Phrases

• “Is this relationship direction modeled the way the data actually flows, or is it backwards?”
• “Is this traversal bounded, or could it run away on a densely connected part of the graph?”
• “Do we have an index on the property this query is starting its match from?”
• “Is this node a potential supernode, and does that change how we should query around it?”
• “Would this be cleaner as its own relationship type instead of a property flag on the node?”

Example Sentences

Reviewing a pull request: “This Cypher query has no depth limit on the variable-length pattern — cap it explicitly, or a highly connected node could make this traversal take much longer than expected.”

Explaining a design decision: “We modeled ‘LIKES’ as a relationship with a timestamp property instead of a separate likes table, since the whole point of using a graph database here is fast traversal between users and content.”

Describing an incident: “The slow endpoint traced back to a missing index — every request was scanning the entire node label before the traversal even started.”

Professional Tips

• Say “traversal” rather than “query” when discussing performance specifically — it signals you’re reasoning about the graph-walking cost, not just general database load.
• Flag “supernode” explicitly when a query might touch a highly connected node — it’s a well-known graph database performance risk worth naming directly.
• Use “relationship direction” precisely in review — a reversed arrow in a Cypher pattern is a common, easy-to-miss bug.
• Distinguish index-backed lookups from traversal cost when explaining performance — they’re separate bottlenecks with separate fixes.

Practice Exercise

1. Explain in two sentences why an unbounded traversal can be dangerous in a densely connected graph.
2. Write a one-sentence code review comment flagging a missing index on a Cypher query’s starting node.
3. Describe, in your own words, what a supernode is and why it can slow down traversals.