Graph Databases

Graph databases treat relationships as first-class citizens: nodes and edges are stored natively, traversals run in constant time per hop, and multi-hop queries beat recursive SQL by orders of magnitude. Reach for them when the relationships are the data — social graphs, fraud rings, knowledge graphs, dependency maps, identity and access trees. For non-graph NoSQL engines (document, key-value, wide-column, time-series, search), see NoSQL Databases.

1. Production Graph Engines

Neo4j & ArangoDB

Two production graph engines compared: Neo4j’s Cypher property-graph model versus ArangoDB’s multi-model approach — with traversal patterns and query semantics.

Amazon Neptune

AWS managed graph DB — Gremlin and openCypher (property-graph) plus SPARQL (RDF). Includes Neptune ML for GNN training and Neptune Analytics for whole-graph algorithms.

JanusGraph

Distributed graph on Cassandra / ScyllaDB / HBase, indexed via Elasticsearch. Speaks Apache TinkerPop’s Gremlin. The standard choice when Neo4j scale isn’t enough.

Dgraph

Distributed native graph DB in Go — predicate sharding, GraphQL-first API, ACID transactions across the whole graph. Built on BadgerDB.

Related on this site

NoSQL Databases

The non-graph NoSQL landscape — in-memory caches, document stores, wide-column tables, key-value engines, time-series, and search. Pick by access pattern.

GraphQL

GraphQL the query language — typed schema, single endpoint, client-driven field selection. An API spec, often paired with graph or relational backends. Don’t confuse it with graph databases.

Vector Databases

Specialized similarity-search databases for embeddings. Often paired with knowledge graphs in modern RAG systems — embeddings retrieve, graphs traverse and reason.

BadgerDB

Pure-Go LSM key-value store — the storage layer underneath Dgraph. WiscKey value separation, ACID transactions.

2. Graph Databases — Advanced Technical Details and Usages

Graph databases overview diagram

2.1 Definition and Core Concept

A graph database is a database system designed to store, manage, and query data as a graph structure. It emphasizes relationships between entities as first-class citizens, rather than treating relationships as secondary constructs (such as foreign keys).

Nodes (Vertices) — entities or objects
Edges (Relationships) — directed or undirected connections between nodes
Properties — key–value attributes on nodes and/or edges

Graph databases are optimized for relationship traversal, pattern matching, and connected-data queries.

2.2 Graph Data Models

Property Graph Model

Nodes and edges both support arbitrary properties
Edges have direction and type
Schema-optional (schema-on-read)

Common usage: social networks, fraud detection, recommendations

RDF (Resource Description Framework) Model

Data stored as triples: subject → predicate → object
Strongly schema-driven using ontologies (RDFS, OWL)
Designed for semantic reasoning and inference

Common usage: knowledge graphs, semantic web, linked data

Labeled Property Graph (LPG)

Extension of property graph
Multiple labels per node
Used by most modern graph engines

2.3 Query Languages

Cypher

Declarative, pattern-matching language
ASCII-art style graph patterns
Optimized for readability and traversal queries

Gremlin

Imperative, traversal-based language
Part of Apache TinkerPop
Supports OLTP and OLAP traversals

SPARQL

Query language for RDF graphs
Supports reasoning and inference queries
Designed for semantic consistency

Native / Proprietary Languages

Custom optimizations for performance
Often support graph analytics primitives

2.4 Storage and Architecture

Native Graph Storage

Adjacency lists stored on disk
Pointer-based traversal
Constant-time edge traversal

Distributed Graph Storage

Graphs partitioned across nodes
Vertex-cut or edge-cut strategies
Trade-offs between locality and scalability

In-Memory Graph Engines

Entire graph stored in RAM
Microsecond-level traversals
Used for real-time decision systems

2.5 Indexing Strategies

Node property indexes — fast node lookup
Composite indexes — multi-property filtering
Relationship-type indexes — traversal pruning
Full-text indexes — graph + text search

Indexes accelerate entry points, while traversals dominate query execution time.

2.6 Query Execution and Optimization

Traversal-Based Execution

Queries executed as step-by-step graph walks
Highly efficient for deep relationship queries

Cost-Based Optimization

Cardinality estimation
Traversal ordering
Early pruning of paths

Path Explosion Control

Depth limits
Uniqueness constraints
Cycle detection

2.7 Transactions and Consistency

ACID transactions for OLTP workloads
Fine-grained locking on nodes and edges
Eventual consistency in large distributed clusters

Most production graph databases support full transactional guarantees.

2.8 Graph Analytics

Centrality Algorithms

PageRank
Betweenness centrality
Closeness centrality

Community Detection

Louvain
Label propagation
Connected components

Similarity and Path Algorithms

Shortest path
K-nearest neighbors
Node similarity metrics

2.9 Common Use Cases

Recommendation Systems

User–item relationships
Real-time personalization

Fraud Detection

Ring detection
Multi-hop transaction analysis

Knowledge Graphs

Entity resolution
Semantic inference

Network and IT Operations

Dependency mapping
Impact analysis

Identity and Access Management

Role hierarchies
Permission propagation

2.10 Integration with Modern Data Platforms

Streaming ingestion (Kafka, Kinesis)
Graph + machine learning pipelines
Hybrid architectures with relational and data lake systems

2.11 Strengths and Limitations

Strengths

Extremely fast relationship traversal
Natural modeling of connected data
Flexible schema

Limitations

Not ideal for large aggregations
Sharding complexity
Less efficient for simple tabular workloads

2.12 When to Use a Graph Database

Data is highly connected
Queries involve multi-hop relationships
Business logic depends on graph structure
Real-time traversal performance is required

Graph databases are most effective when relationships are the data, not just attributes.

3. Most Popular Graph Databases

Widely Adopted (Enterprise & Production)

Neo4j — Property graph model; Cypher query language
Amazon Neptune — Fully managed service; supports Gremlin, SPARQL, and openCypher
TigerGraph — High-performance parallel graph analytics; GSQL
ArangoDB — Multi-model database combining graph, document, and key-value; AQL

Open-Source / Infrastructure-Centric

JanusGraph — Distributed graph database running on Cassandra, HBase, or ScyllaDB
Dgraph — Native distributed graph engine with GraphQL+- query language
OrientDB — Multi-model graph and document database with SQL-like queries

In-Memory / Real-Time Graph Engines

RedisGraph — In-memory graph database optimized for low-latency traversal

RDF / Semantic Graph Databases

AllegroGraph — RDF triple store; SPARQL querying; semantic reasoning and knowledge graphs

Cloud-Native Graph Offerings

Azure Cosmos DB (Gremlin API) — Managed property graph service
DataStax Enterprise Graph — Graph layer built on Apache Cassandra infrastructure

These platforms represent the most commonly used graph databases across enterprise systems, open-source ecosystems, real-time applications, semantic technologies, and cloud-native architectures.

Featured Videos

Twelve hand-picked talks and tutorials covering each engine on this page, plus the foundational graph-DB concepts behind them. Click any thumbnail to play in place. Roughly grouped: foundations + Neo4j (row 1), ArangoDB + Amazon Neptune intros (row 2), Neptune deep dive + JanusGraph + Dgraph (row 3).

What is a graph database? (in 10 minutes)

Neo4j — Ten-minute primer on nodes, edges, and why traversal beats recursive joins. The fastest way into section 2.1.

Fireship — Whirlwind 100-second tour of Neo4j and the property-graph model. A pre-flight check before the longer tutorials below.

freeCodeCamp.org — Long-form Neo4j course covering install, the browser, Cypher patterns, and graph modeling. Pairs with sections 2–4.

Neo4j — Official walkthrough of Cypher's ASCII-art pattern syntax. Maps directly to section 2.3.1 (Cypher).

LearnCode.academy — Beginner-friendly tour of ArangoDB's multi-model approach (graph + document + key-value) and AQL. Sets up the ArangoDB card above.

Arango (official) — Why one engine for graph, document, and key-value beats stitching three together. Background for section 2.2.3 (LPG) and the Neo4j vs. ArangoDB comparison page.

Amazon Web Services — Official intro to Neptune — Gremlin, openCypher, and SPARQL on one managed service. Pairs with the Amazon Neptune card.

AWS Developers — Virtual workshop combining graph-DB fundamentals with a Neptune deep dive and live demo. Bridges sections 2 and the Neptune deep dive page.

AWS re:Invent 2020: Deep dive on Amazon Neptune

AWS Events — re:Invent 2020 deep dive on Neptune internals: storage, replication, query optimization. Reference for Neptune ML and Neptune Analytics.

The Linux Foundation — Jason Plurad (IBM) on JanusGraph's pluggable storage (Cassandra / HBase / ScyllaDB) and TinkerPop Gremlin. Maps to the JanusGraph card.

Fireship — 100-second intro to Dgraph — predicate sharding, GraphQL-first, written in Go. Pairs with the Dgraph card.

Dgraph - A distributed graph database written in Go

Singapore Gophers — GopherCon SG 2017 talk on Dgraph's architecture, distributed transactions, and the BadgerDB storage layer. The detailed companion to the Fireship clip.

↑ Back to Top