Free audit

View Audit Scope
JusDBNeo4j Consulting · Index-Free Adjacency · Cypher PROFILE · Autonomous Clustering

Eliminate supernode stalls and tune Neo4j Cypher & Page Cache for millisecond multi-hop traversals.

Neo4j’s index-free adjacency engine traverses millions of relationships per second when the graph topology, Cypher execution plans, and off-heap Page Cache are engineered together. When a single hub node accumulates hundreds of thousands of generic edges, or when `Eager` operators and undersized Page Caches trigger JVM G1GC pauses, multi-hop queries stall and Raft leaders step down. JusDB’s graph database architects refactor supernodes, optimize `PROFILE` plans, tune Neo4j 5 Autonomous Clusters, and build hybrid Vector + GraphRAG pipelines across AuraDB and Kubernetes.
Our engineering team is in India (IST, UTC+5:30). Or request a free audit of one database instance.
  • 15 minutes P1 response target under a 24x7 support agreement
  • O(1) hop supernode remediation & relationship sub-typing
  • Neo4j 5 Autonomous Clustering, GDS & Vector GraphRAG
  • 24 supported database technologies

Neo4j Architecture Matrix

Index-Free Adjacency, Relationship Specificity & Supernode Mitigation

CRITICAL · SUPERNODES

Neo4j achieves constant-time O(1) hop traversal via index-free adjacency pointer chains. However, when a dense hub node accumulates hundreds of thousands of generic relationships, traversing that single supernode scans every pointer record and stalls p99 latency.

We refactor dense hub nodes using relationship sub-typing (`TRANSACTED_2026_11`), fan-out bucket nodes, and directional selectivity so multi-hop traversals only evaluate relevant pointer chains.

Audit graph model & supernodes

Engineered across Neo4j, AuraDB, PostgreSQL, MongoDB & multi-cloud Kubernetes estates

  • Innoviti
  • Blitz
  • Freecharge
  • Nango
  • Recochain
  • Screen Facts
  • Nexora
  • WeCredit

01 · Production Graph Failure Modes

Six Neo4j bottlenecks we diagnose inside pointer chains, Cypher plans, and the JVM.

Scaling up server RAM without separating JVM heap from the off-heap Page Cache or refactoring high-degree supernodes often makes Neo4j GC pauses worse. Here is how we isolate and resolve the real bottleneck.

Symptom / Telemetry SignalArchitectural Root CauseHow We VerifyProduction Remediation
SUPERNODE_DEGREE_EXPLOSION · 2-hop query takes 18+ secondsA celebrity user, country node, or status hub accumulates 500,000+ edges under a single generic relationship type (`RELATED_TO`), forcing every traversal through that node to scan the entire relationship chain.Run `PROFILE` to inspect `Expand(All)` db-hits-per-row ratio and query `COUNT { (n)--() }` degree distribution across node labels.Promote low-cardinality hubs into node labels or properties where appropriate, sub-type relationships by time/category (`PURCHASED_2026_Q4`), or introduce intermediate fan-out bucket nodes.
EAGER_OPERATOR_OOM · Bulk Cypher write crashes JVM heapCombining `MATCH` and `CREATE`/`MERGE` in a single Cypher statement without isolation forces the planner to insert an `Eager` operator, materializing all intermediate rows in JVM heap to prevent Halloween-problem read/write conflicts.Run `EXPLAIN` on write pipelines to detect `Eager` plan operators and inspect `db.memory.transaction.total.max` violations in `debug.log`.Split read and write scopes carefully, batch mutations via `CALL { ... } IN TRANSACTIONS OF 1000 ROWS`, and set `dbms.memory.transaction.max` per-query safety limits.
PAGECACHE_THRASHING · High disk IOPS & erratic traversal latencyThe active store files (`neostore.nodestore.db`, `relationshipstore.db`, `propertystore.db`) exceed `server.memory.pagecache.size`, turning in-memory pointer hops into synchronous SSD page faults.Check JMX / Prometheus `neo4j_page_cache_hits` vs `neo4j_page_cache_page_faults` so cache hit ratio stays above 98.5%.Right-size `server.memory.pagecache.size` to hold the hot graph store plus 20% headroom, move verbose text blobs out of graph properties, and run offline store compaction (`neo4j-admin database copy --compact-node-store`).
JVM_G1GC_RAFT_STEPDOWN · Cluster leader elections under loadOversized JVM heap (> 31 GB compressed oops boundary) or unbounded variable-length path traversals (`[*1..10]`) trigger multi-second G1GC pauses that exceed `dbms.cluster.raft.leader_failure_detection_window`.Correlate `gc.log` safepoint pause durations (`Pause Young` / `Pause Full`) with Raft leader step-down events in `debug.log`.Pin JVM heap between 16 GB and 31 GB (`server.memory.heap.initial_size = max_size`), bound all variable-length patterns (`[*1..4]`), and tune G1GC region sizing.
BOLT_ROUTING_HOTSPOT · All reads hit the Raft primaryConnecting applications via direct `bolt://` URIs or failing to mark read sessions with `AccessMode.READ` sends all analytical and lookup traffic to the single Raft write leader.Inspect per-server active Bolt connections and query execution counts via `SHOW TRANSACTIONS` across all cluster members.Switch all client drivers to cluster-aware `neo4j://` URIs, separate `READ` and `WRITE` session factories, and pass causal bookmarks (`session.lastBookmarks()`) only where read-your-own-writes is required.
GDS_VECTOR_HEAP_CONTENTION · Analytics starves OLTP queriesRunning heavy Graph Data Science (`gds.pageRank`, `gds.louvain`) in-memory graph projections or large HNSW vector index builds on the same primary nodes serving transactional Cypher traffic.Run `CALL gds.memory.list()` and inspect off-heap + on-heap allocation spikes alongside OLTP query latency.Allocate dedicated secondary cluster servers (`SET TOPOLOGY 3 PRIMARIES, 2 SECONDARIES`) or read-only analytical replicas for GDS workloads, and pre-estimate memory via `gds.*.estimate()`.
Evaluation Vector
JusDB DBRE
In-House DBALegacy AgencyDeveloper Generalist
Index-Free Adjacency Graph Data Modeling & Schema DesignArchitects native pointer-based graph topologies with optimized label hierarchies and relationship types, exploiting double-linked record pointers for constant O(1) traversals without relational JOIN bottlenecks.Treats Neo4j like a relational database; over-indexes node properties and models many-to-many relationships with intermediate join nodes, defeating index-free adjacency benefits.Directly mirrors third-normal-form (3NF) relational tables into graph nodes and foreign-key edges, introducing severe traversal overhead and pointer dereferencing bottlenecks.Stores denormalized monolithic JSON payloads inside node properties and uses arbitrary undirected relationships, resulting in unpruned graph traversals.
Declarative Cypher PROFILE / EXPLAIN Query Execution PlansAudits PROFILE and EXPLAIN execution plans down to db-hits, operators (ExpandAll, CartesianProduct, Eager), and memory allocations to eliminate unindexed scans and ensure pipeline streaming.Rely on basic Cypher syntax without inspecting execution trees, missing expensive Eager operators that break streaming execution and inflate JVM heap memory.Writes unparameterized Cypher queries causing continuous query cache churn and compilation latency, or falls back to client-side iteration loops.Employs unbounded variable-length traversals (e.g. -[*]-) without path limits or directional constraints, triggering accidental full-graph traversals.
Supernode Degree Explosion Mitigation & Relationship GroupingImplements fan-out partitioning, relationship directionality, categorization, and intermediate grouping nodes to cap traversal branch factors on 100k+ degree hub nodes.Leaves high-degree supernodes unmitigated, resulting in traversal thread lockups, severe GC pauses, and multi-second P99 query latency degradation.Recommends vertical RAM upgrades rather than addressing graph topology skew, relationship group indexing, or direction-specific edge typing.Attempts client-side filtering on all incoming edges of dense nodes, triggering JVM out-of-memory crashes during relationship expansion.
Graph Data Science (GDS) In-Memory Projection SizingCalculates exact off-heap projected graph memory requirements for PageRank, Louvain, and GraphSAGE embeddings, tuning concurrency threads and write-back pipelines without starving core DBMS heap.Executes GDS graph projections directly on production transactional cluster members without memory bounds, causing garbage collection stalls and Raft heartbeat drops.Lacks understanding of GDS in-memory graph projections; exports graph dumps to run external Python/NetworkX scripts via slow BOLT queries.Allocates arbitrary JVM heap to GDS projections without configuring G1GC regions, triggering fatal OutOfMemoryError crashes.
Autonomous Clustering Raft Consensus & Read Replica BalancingArchitects Neo4j 5+ Autonomous Clustering with dedicated Raft consensus groups, dynamic database allocation, and routing-aware Neo4j driver configurations across primary and secondary servers.Maintains legacy Causal Cluster configurations with static core/read-replica topologies, failing to leverage autonomous database reassignment and server tags.Deploys standalone single-instance VMs with asynchronous file backups, providing zero automated failover or cross-zone high availability.Connects applications directly to specific cluster member endpoints without routing drivers, leading to write failures during leader re-election.
Neo4j AuraDB Enterprise vs Self-Managed TCO SizingDelivers comprehensive TCO modeling comparing AuraDB Enterprise vs self-managed on Kubernetes (Neo4j Helm/Operator), evaluating JVM pagecache ratios, backup I/O, and cloud infrastructure licensing.Over-provisions self-managed cloud instances with idle compute and miscalculated disk IOPS, incurring high operational maintenance overhead.Pushes proprietary managed services without evaluating data transfer egress costs, compliance boundaries (SOC 2, HIPAA), or long-term growth curve.Selects low-tier AuraDB instances without sizing off-heap pagecache for working-set graph storage, triggering continuous disk I/O thrashing.

02 · Consulting Workstreams

Full-lifecycle graph engineering across Cypher, Autonomous Clustering, and GDS.

Every engagement delivers concrete Cypher refactorings, validated `neo4j.conf` memory configurations, and benchmarked traversal plans.

01 · GRAPH DATA MODELING

Index-Free Adjacency Modeling & Supernode Remediation

We design property graph schemas where questions are answered by local pointer hops rather than global index scans. We decide what belongs as a Node vs Relationship vs Property, encode specificity into relationship types, and break up high-degree supernodes.

Index-free adjacency · Relationship sub-typing · Fan-out bucketing

02 · CYPHER PLAN TUNING

Cypher PROFILE / EXPLAIN Optimization & Index Engineering

We audit slow queries in `query.log`, eliminate `CartesianProduct`, `AllNodesScan`, and `Eager` operators, bound variable-length traversals, and design selective RANGE, TEXT, POINT, and full-text Lucene indexes backed by uniqueness and existence constraints.

PROFILE / EXPLAIN · Eager elimination · CALL IN TRANSACTIONS · RANGE/TEXT indexes

03 · MEMORY & JVM TUNING

Page Cache, JVM Heap (G1GC) & Transaction Memory Governance

We tune `neo4j.conf` memory boundaries across off-heap Page Cache (`server.memory.pagecache.size`), JVM heap (`16 GB to 31 GB` compressed oops zone), and transaction memory ceilings (`dbms.memory.transaction.global_max`) to stop OOM kills and GC stalls.

server.memory.pagecache.size · G1GC tuning · transaction.global_max

04 · AUTONOMOUS CLUSTERING

Neo4j 5 Autonomous Clustering, Causal Routing & AuraDB Architecture

We architect resilient Neo4j 5 clusters across Kubernetes, VMs, or Neo4j AuraDB (Professional, Business Critical, Virtual Dedicated Cloud). We configure per-database primary/secondary topologies, Raft failure detection windows, and `neo4j://` driver routing.

SHOW SERVERS · ALTER DATABASE TOPOLOGY · neo4j:// routing · Causal bookmarks

05 · GDS & HYBRID VECTOR RAG

Graph Data Science (GDS), APOC Pipelines & Hybrid GraphRAG

We engineer production Graph Data Science workflows (PageRank, Louvain, Node2Vec, FastRP, shortest path) on isolated secondary instances, refactor legacy APOC triggers/procedures, and build hybrid GraphRAG retrieval combining native HNSW vector indexes with multi-hop Cypher context.

GDS graph projections · HNSW vector index · GraphRAG Cypher · APOC Core

06 · MIGRATION & SRE

neo4j-admin Bulk Import, v4-to-v5 Upgrades & 24x7 DBA Operations (Where Contracted)

We migrate relational, RDF, or TinkerPop graphs into Neo4j using `neo4j-admin database import full`, execute rolling upgrades from Neo4j 4.4 LTS to Neo4j 5+, validate online backups (`neo4j-admin database check`), and provide 24x7 on-call DBA support under a 24x7 support agreement.

neo4j-admin database import · v4.4 to v5 upgrades · Online backup checks

03 · Responsibility Boundary & Response Targets

Where AuraDB or Kubernetes infrastructure ends and JusDB Graph DBA ownership begins.

Even on managed Neo4j AuraDB, the cloud platform cannot prevent a supernode traversal, an `Eager` Cypher query, or a `bolt://` driver misconfiguration from saturating cluster memory.

Shared Responsibility Matrix (Neo4j AuraDB / Self-Hosted)

Cloud Infrastructure, AuraDB Control Plane & Storage Volumes

AuraDB / Cloud Provider

Neo4j AuraDB or your cloud provider manages underlying VMs, NVMe block storage, and physical network links.

JusDB Graph Database Architects

We size instance RAM-to-store ratios, configure Kubernetes StatefulSets or AuraDB tiers, and isolate analytical compute from OLTP.

Property Graph Schema, Supernode Topology & Relationship Design

AuraDB / Cloud Provider

Provides the native graph storage engine (`nodestore`, `relationshipstore`, `propertystore`) and Cypher runtime.

JusDB Graph Database Architects

We model labels, relationship types, and fan-out buckets so traversals never stall on million-edge supernodes.

Cypher Query Plans (`PROFILE`), Indexing & Transaction Memory Caps

AuraDB / Cloud Provider

Executes cost-based Cypher planning and enforces configured `neo4j.conf` memory thresholds.

JusDB Graph Database Architects

We rewrite `Eager` and `CartesianProduct` queries, author composite RANGE/TEXT/VECTOR indexes, and tune `transaction.global_max`.

Autonomous Clustering Routing, Backups & 24x7 Incident Response (Where Contracted)

AuraDB / Cloud Provider

Provides Raft consensus replication, `neo4j://` routing tables, and scheduled snapshot tooling.

JusDB Graph Database Architects

We configure driver `READ`/`WRITE` session separation, verify backup store consistency, and provide 24x7 DBA response under a 24x7 support agreement.

Target Incident Response Matrix

P1 to P4 Engineering Targets (15m / 30m / 60m / 90m)

Alerts go to a senior Neo4j engineer who works in Cypher PROFILE diagnostics, G1GC heap analysis, and Raft quorum recovery. Initial-response targets are 2 to 4 hours during covered business hours, Mon–Fri 09:00–18:00 IST (UTC+5:30). Where your service agreement includes 24x7 on-call, the initial-response target for P1 incidents is 15 minutes. Targets are not resolution guarantees.

P1 · CriticalTarget: 15 minutes

Production database down, primary unreachable, data corruption risk, or active failover event.

24x7 on-call (under your service agreement) · Direct PagerDuty, Opsgenie, or phone page plus incident bridge

P2 · HighTarget: 30 minutes

Severe latency spike, replication lag climbing rapidly, connection exhaustion, or degraded HA node.

24x7 on-call (under your service agreement) · On-call alert plus shared Slack or Teams channel

P3 · MediumTarget: 60 minutes

Non-critical slow query regression, staging issue, backup warning, or replication check alert.

24x7 on-call (under your service agreement) · Shared Slack or Teams channel or support ticket

P4 · LowTarget: 90 minutes

Configuration question, index advisory, planned schema review, or general operational request.

24x7 on-call (under your service agreement) · Shared Slack or Teams channel or support ticket

Facing a Neo4j JVM OutOfMemoryError stall or Raft cluster split-brain? Open an emergency escalation →

04 · Interactive Graph & Cluster Simulator

See how sub-typed edges, Page Cache fit, and secondary offload transform Neo4j.

Toggle across three production states to see how resolving supernodes, tuning off-heap Page Cache vs JVM heap, and routing GDS/GraphRAG to Neo4j 5 secondaries stabilize p99 latency.

Neo4j Supernode, Page Cache & Autonomous Cluster Simulator

Application and routing

Direct bolt:// Clients to Single Primary Server to 800k-Edge Supernode + Page Cache Faults

DEGRADED · GC PAUSES + SUPERNODE STALL
  • Primary Server #1 (Direct bolt:// Endpoint)

    Handling All Reads + Writes · 48 GB Heap (No Compressed Oops)

    4.2s G1GC PAUSE · RAFT LEADER STEP-DOWN

  • Supernode Traversal (:Country {code: 'US'})

    Scanning 850,000 Generic :LOCATED_IN Relationships

    14.8s QUERY LATENCY · 38% PAGE CACHE HIT

  • Primary Servers #2 & #3

    Replicating Raft Log Only (Idle for Reads)

    READ CAPACITY UNUSED

Connecting via `bolt://` routes all queries to one server, while traversing a generic 850k-edge supernode with an undersized Page Cache and oversized 48 GB JVM heap triggers disk thrashing and Raft leader timeouts.

05 · Representative Deliverable

Production neo4j.conf memory bounds and Eager-free Cypher batching.

Every Neo4j engagement delivers exact `neo4j.conf` memory and transaction settings calibrated to your store files, live transaction inspection queries, and batched Cypher migration scripts.

  • 01Compressed Oops JVM Heap + Off-Heap Page Cache: Pins JVM heap at 24 GB and dedicates 84 GB to `server.memory.pagecache.size` on a 128 GB host.
  • 02Per-Transaction Memory Guardrails: Enforces `dbms.memory.transaction.max=512m` so a single runaway traversal aborts cleanly instead of crashing the JVM.
  • 03Chunked Subquery Mutations: Uses CALL { ... } IN TRANSACTIONS OF 1000 ROWS to refactor supernodes online without triggering Eager heap exhaustion.

neo4j-memory-and-cypher-remediation.cypher

# 1. neo4j.conf: Production memory & transaction guardrails (128 GB RAM host)
server.memory.heap.initial_size=24g
server.memory.heap.max_size=24g
server.memory.pagecache.size=84g

dbms.memory.transaction.total.max=16g
dbms.memory.transaction.max=512m
dbms.transaction.timeout=30s

# 2. Cypher: Inspect live cluster topology, active queries & memory footprint
SHOW SERVERS YIELD name, address, state, health, hosting;
SHOW DATABASES YIELD name, role, currentStatus, writer;

SHOW TRANSACTIONS
YIELD transactionId, username, currentQuery, elapsedTime, allocatedBytes
WHERE elapsedTime.seconds > 5
RETURN transactionId, username, elapsedTime, allocatedBytes, currentQuery
ORDER BY allocatedBytes DESC;

# 3. Cypher: Batch large graph mutations without Eager heap exhaustion
MATCH (u:Account)
WHERE u.migrationStatus = 'PENDING_BUCKET'
CALL {
  WITH u
  MERGE (b:ActivityBucket {bucketKey: u.tenantId + '_' + u.yearMonth})
  SET u.migrationStatus = 'BUCKETED',
      u.updatedAt = datetime()
} IN TRANSACTIONS OF 1000 ROWS;

06 · Engagement Models & Scope

Flexible engagements from Cypher & supernode audits to Graph SRE (24x7 on-call under your service agreement).

Start with a fixed-scope Neo4j architecture and Cypher audit, engage our engineers for a Neo4j 5 upgrade or GraphRAG sprint, or retain a 24x7 graph DBA team under a 24x7 support agreement.

Implementation SprintRecommended

Supernode Refactoring, v4-to-v5 Upgrade & GraphRAG / GDS Sprint

Hands-on execution to refactor production graph schemas, migrate relational/graph data via `neo4j-admin database import`, upgrade Neo4j 4.4 to Neo4j 5 Autonomous Clustering, or deploy hybrid HNSW Vector + Cypher GraphRAG.

Included in scope

  • Online batched Cypher schema refactoring (`CALL IN TRANSACTIONS`) and composite index rollout
  • Neo4j 4.4 LTS to Neo4j 5+ rolling cluster upgrade and deprecated Cypher/APOC syntax migration
  • Production GDS pipeline isolation on secondary nodes and hybrid Vector + GraphRAG retrieval tuning
Fixed-Scope Audit

Neo4j Graph Model, Cypher PROFILE & Memory Diagnostic Audit

A deep engineering audit of your Neo4j AuraDB or self-hosted cluster: node degree distribution and supernode analysis, top-25 slow Cypher `PROFILE` rewrites, Page Cache vs JVM heap sizing, and cluster routing inspection.

Included in scope

  • Supernode degree forensics and concrete relationship sub-typing / fan-out bucket refactoring plan
  • Rewrite of top slow or memory-heavy Cypher queries (`Eager`, `CartesianProduct`, unbounded paths)
  • Tuned `neo4j.conf` memory, GC, and transaction guardrail manifest for your exact store size
Ongoing Retainer

Managed Neo4j SRE, Cluster Operations & On-Call DBA Support

Continuous operational ownership for mission-critical Neo4j clusters across Kubernetes, cloud VMs, or AuraDB, backed by 24x7 incident response under a 24x7 support agreement.

Included in scope

  • P1 critical acknowledgment target: 15 minutes under a 24x7 support agreement
  • 24x7 monitoring of Page Cache hit ratios, JVM G1GC pauses, Raft leader stability, and transaction heap under a 24x7 support agreement
  • Scheduled online backups, `neo4j-admin database check` consistency validation, and store compaction

Procurement and security

Ready for legal and security review.

All engagements include NDA execution, least-privilege bastion or AuraDB access, and reproducible Cypher/Helm/Terraform artifacts.
  • Mutual NDA before any access
  • Named individual accounts only
  • Read-only access by default
  • ISO 27001 & SOC 2 Type II: aligned, certification in progress
  • Deployment Coverage

    Vendor-neutral across Neo4j AuraDB, self-hosted Enterprise & Community Edition

  • Support Coverage

    2 to 4 hours (During covered business hours) · 15 minutes under a 24x7 support agreement

  • Security & Access Governance

    ISO 27001 & SOC 2 Type II: aligned, certification in progress · Zero-trust bastion access with RBAC / fine-grained graph privileges

  • Commercial Structure

    Fixed-fee graph & Cypher audits, milestone migration sprints, or monthly SRE retainers

07 · Technical & Architecture FAQ

Common questions on Neo4j consulting.

Direct answers from our graph database architects on supernode mitigation, Page Cache vs JVM heap sizing, `Eager` Cypher operators, Neo4j 5 Autonomous Clustering, and Hybrid GraphRAG.

Still have a question?

Ask it on a scoping call. No production access needed.

Book a 30-min scoping call (opens Google Calendar in a new tab)

What is a supernode in Neo4j, and how do you fix supernode latency spikes?

In Neo4j, index-free adjacency stores each node's relationships as a doubly linked list of pointers on disk and in the Page Cache. While traversing a normal node with 50 relationships takes microseconds, a 'supernode' (a hub node with 100,000 to millions of relationships, such as a `:Country`, `:Merchant`, or `:Status` node) forces Neo4j to iterate through hundreds of thousands of relationship records just to filter by type or direction. We remediate supernodes using three techniques: (1) relationship sub-typing (splitting `:TRANSACTED` into `:TRANSACTED_2026_11` or `:PURCHASED_ELECTRONICS`), (2) fan-out bucketing (inserting intermediate time or hash bucket nodes between the hub and leaves), and (3) converting static hub categories into indexed node properties or labels.

How should we size Neo4j Page Cache vs JVM Heap on production servers?

Neo4j uses two separate memory regions: the off-heap Page Cache (`server.memory.pagecache.size`), which caches the on-disk graph store files (`nodestore`, `relationshipstore`, `propertystore`) and native indexes, and the JVM Heap (`server.memory.heap.initial_size` and `max_size`), which holds active Cypher query execution state, transaction state, and Graph Data Science objects. Setting the JVM heap above `31 GB` disables 32-bit compressed object pointers (Compressed Oops) and increases garbage collection pause times. On a 128 GB RAM server, we typically pin initial and max JVM heap between `16 GB` and `24 GB`, allocate `80 GB to 88 GB` to the off-heap Page Cache so the entire graph topology stays in RAM, and reserve the remainder for the OS and native buffers.

Why do our bulk Cypher writes fail with OutOfMemoryError or Eager operator bottlenecks?

When a Cypher query contains multiple `MATCH` and `MERGE`/`CREATE`/`SET` clauses, the query planner may insert an `Eager` operator to materialize every intermediate row into JVM heap before executing subsequent writes (preventing subsequent reads from seeing newly mutated graph elements). On large datasets, `Eager` operators and single-transaction bulk writes exhaust heap memory. We eliminate `Eager` operators by restructuring Cypher pipelines, isolating read and write phases, batching mutations with `CALL { ... } IN TRANSACTIONS OF 1000 ROWS`, and enforcing `dbms.memory.transaction.max` and `dbms.memory.transaction.global_max` safety limits.

How does Neo4j 5 Autonomous Clustering differ from legacy Causal Clustering?

In Neo4j 4.x, every server in a cluster had a fixed global role (`CORE` or `READ_REPLICA`). Neo4j 5 introduced Autonomous Clustering, where any server can host primary (Raft voter) or secondary (asynchronous replica) allocations on a per-database basis using `ALTER DATABASE foo SET TOPOLOGY n PRIMARIES, m SECONDARIES`. This allows you to run a 3-primary highly available transactional graph alongside a 1-primary / 2-secondary analytical graph on the same cluster fleet, and offload heavy read or GDS workloads onto dedicated secondary servers via server tags and `neo4j://` routing.

Why must applications use neo4j:// routing URIs instead of bolt:// in a cluster?

A `bolt://` URI opens a direct point-to-point TCP connection to a single Neo4j server and ignores the cluster routing table. If your application connects via `bolt://`, all read and write queries hit that one host, and if Raft leadership moves to another node, write transactions fail with `NotALeader`. Using the `neo4j://` (or `neo4j+s://`) scheme instructs the official Neo4j driver to fetch the cluster routing table, automatically send `WRITE` sessions to the current Raft leader, distribute `READ` sessions across primaries and secondaries, and propagate causal bookmarks so readers never observe stale state.

How do you combine Neo4j HNSW vector indexes with Cypher for GraphRAG?

Pure vector database similarity search retrieves isolated text chunks based on embedding cosine similarity, often missing structural relationships, ownership hierarchies, and multi-hop dependencies. In Neo4j 5+, we configure native HNSW vector indexes (`CREATE VECTOR INDEX ...`) directly on document or entity nodes. A single hybrid GraphRAG query first executes `CALL db.index.vector.queryNodes(...)` to find the top-K semantically similar entry nodes in milliseconds, and immediately expands 2 to 3 hops across the knowledge graph via index-free adjacency to return rich, grounded relational context to the LLM.

What is the fastest way to load hundreds of millions of nodes and relationships into Neo4j?

Loading hundreds of millions of records over Bolt using `UNWIND` and `MERGE` can take many hours because every batch acquires transactional locks and writes Raft logs. For initial migrations or full graph rebuilds on self-hosted clusters (or before importing a `.dump` into AuraDB), we prepare pre-deduplicated CSV files with header ID spaces and run `neo4j-admin database import full`, which builds the binary `nodestore` and `relationshipstore` files offline at millions of records per second. For incremental live ingestion, we use batched `UNWIND` with `CALL { ... } IN TRANSACTIONS` keyed on indexed node constraints.

What response times do you provide for production Neo4j incidents?

Under a 24x7 support agreement, our target initial response times are: P1 (Critical) within 15 minutes; P2 (High) within 30 minutes; P3 (Medium) within 60 minutes; P4 (Low) within 90 minutes. During standard business-hours consulting retainers, our response target is 2 to 4 hours. Every incident routes directly to a principal graph database engineer.

Talk to a Principal Graph Database Architect

Ready to eliminate supernode bottlenecks and scale Neo4j with predictable latency?

Share your slow Cypher `PROFILE` plans, `neo4j.conf` memory configuration, or Neo4j 5 cluster topology for a pragmatic engineering assessment.