The heap keeps exhausting
Large result sets materialised in a single transaction, a query returning all shortest paths across the graph, or a heap sized for a dev laptop running production load.
Heap and page cache sized for the workload
Running Neo4j?
Graph databases shine on the queries that are miserable in SQL and punish you on the queries that are easy. Teams come to us when a Cypher query that worked at ten thousand nodes falls over at ten million, when the heap keeps crashing under a mixed workload, or when a causal cluster refuses to elect a leader. We get it stable and then we make it quick.
What it is
Neo4j is a native graph database built around the property graph model: nodes, relationships, and properties on both. It was founded in Sweden in 2007 by Emil Eifrem and others, and its query language Cypher became the basis of the ISO GQL standard ratified in 2024.
The database runs as a single instance or as a causal cluster with raft based consensus, and offers a managed service called AuraDB on AWS, GCP and Azure. It is used where traversal queries dominate: fraud rings, recommendation graphs, identity resolution, access control, knowledge graphs feeding retrieval augmented generation. For pure document or tabular workloads it is usually the wrong tool, which is a conversation we have often.
The honest version
No technology is all upside. This is where Neo4j earns its place and where it tends to cause trouble.
Sound familiar?
The Neo4j problems that bring people to us, and what you have once each one is fixed.
Large result sets materialised in a single transaction, a query returning all shortest paths across the graph, or a heap sized for a dev laptop running production load.
Heap and page cache sized for the workload
A query that works on cold data falls over on peak traffic because the planner chose a full label scan or a cartesian product that nobody caught in review.
Plans inspected, indexes in place
Concurrent transactions acquiring locks on the same relationships in opposite orders, which Neo4j correctly aborts but which the application then retries badly.
Lock order fixed, retries sensible
Network partitions, clock skew between members, or a follower that lost its store and cannot catch up through copy. The cluster is up but will not accept writes.
Cluster healthy, leader stable
A kernel panic, a full disk or a mistimed power event left the transaction log in a state the recovery path cannot finish, and the database will not start.
Recovered from logs or restored
Two patterns in the same MATCH clause that share no variable, so every node on one side pairs with every node on the other, which quickly becomes billions of rows.
Pattern rewritten, planner guided
An index was created but the application started querying before it finished populating, or the schema has an index on label and property that the query does not touch.
Indexes verified, queries routed through them
The page cache is sized far smaller than the working set, so every query fetches from storage, and performance looks nothing like a benchmark on the same hardware.
Cache tuned to the working set
What we do
Fix one stuck query, or hand us the whole cluster and its ops.
How it works
Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.
We fix the cause, not the symptom. If something is down, getting it back up comes first.
Backups, monitoring, updates and access, so the same problem can't quietly come back.
You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.
Often found together
We work on the whole stack, so the problem can be wherever it actually is.
Only if your queries are genuinely about relationships. Friend of friend, shortest path, fraud ring detection and recommendation graphs are good fits. Tabular reporting, time series and simple document lookups are almost always cheaper and faster to run in Postgres. We will say so if your use case is in the second bucket.
Three usual suspects. A missing index on the label and property the query starts from, a cartesian product hidden inside a seemingly innocent MATCH, and a planner that picked a scan where a seek would have worked. PROFILE shows which of the three it is, and the fix is usually small once the cause is clear.
Yes, that is common work. We inventory the deployment, work out what the real backup and recovery story is, bring heap and page cache onto sensible values, and document the cluster so your team is no longer dependent on whoever set it up.
AuraDB saves you the JVM tuning, upgrade cycles and cluster operations, and pays back quickly for teams without a database specialist on staff. Self hosted makes sense when you need custom configuration, strict data residency or you already run a lot of JVM workloads. We will cost both against your traffic rather than guess.
The graph holds the entities and relationships, the LLM handles language. We model the domain as a graph, generate embeddings on nodes where semantic similarity helps, and wire Cypher traversals into the retrieval step so the model sees connected context rather than isolated chunks. The result is answers grounded in your structure rather than a vector search in the dark.
Estimates do not cost anything. Send a query plan, a heap dump or just a description of what the cluster is doing, and we come back with a price up front.
Free estimate
Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.
Your message is with a real person, and we'll get back to you soon.
Rather talk now? Call us: