Ultra-high-performance data systems
-
The same queries, finished sooner. Nothing chases pointers around memory, so the work that used to dominate a query isn't slow — it isn't there.
-
A single, lightweight engine that runs anywhere and embeds directly inside your product. No heavy stack to babysit.
-
Efficiency is savings. The same work on a fraction of the memory means smaller instances and a lighter monthly bill.
TETRA SaaS
TETRA,
fully managed.
A managed graph layer that sits on top of the stack you already run. Point it at your data, keep your app and queries, and let TETRA handle the engine, scaling and ops.
- Layers onto your existing database and app. Nothing to rip out.
- Scales itself. Pay for the queries you run, not reserved RAM.
- Zero ops: updates, backups and failover handled for you.
The graph layer, run for you. Point a Bolt driver at it and send Cypher. Updates, backups and failover are ours.
Untouched. Same Bolt driver, same Cypher. The connection string is the change.
Stays where it is. TETRA layers on top of what you already run rather than replacing it, so there is nothing to rip out.
Wherever it already lives. No reserved RAM to size, no cluster to stand up. You pay for the queries you run.
Flat managed pricing on top of your stack. No reserved RAM, no idle cost.
- Managed graph layer over your existing data
- Backups, updates & failover included
- Retina 2D / 3D viewer included
TETRA Embedded · On-prem
Build TETRA
into your product.
One small binary you ship inside your application: on a laptop, at the edge, or in your customer's private cloud. For TETRA, on-prem and embedded are the same thing: there is no separate cluster to run, so there is nothing to install in the datacentre but your own product.
- Embeds as a single file, so you distribute it like any other library.
- Drop-in replacement. Keep your current queries and connections.
- Runs anywhere, air-gapped and offline-capable, with no tuning to maintain.
- Lost your embedded graph database? Cypher-compatible, so the port is a short one.
Collapsive architecture
We collapse the time and money it takes to build and run software.
A pointer-and-index engine spends its life chasing references around memory. TETRA does not chase them at all. Once nothing is chasing pointers, whole layers of the stack have nothing left to do: no index to maintain, no cache to warm, no cluster to babysit. That is what collapses. Not the query. The stack.
A graph stack today
- Your application
- Cypher, over Bolt
- Index layer
- Page cache
- Storage engine on a JVM heap
- Replicas, and a cluster to coordinate
- Warm-up, tuning, capacity planning
The same stack, on TETRA
- Your application unchanged
- Cypher, over Bolt unchanged
- The TETRA engine one binary · one file
Every layer that disappeared had the same job: finding things quickly in a structure
built for chasing pointers. Change the structure and the job stops existing, so
there is nothing left to maintain, warm, or babysit.
How we change it is math, and the math is ours for now. It is the
one thing on this page we're not publishing yet, so the benchmarks ship with their
datasets and reproduction steps instead, and you're welcome to watch it run on a
graph of your own.
Where TETRA fits
- Graph workloads that outgrew their engine. The RAM bill is the roadmap.
- Products that must ship the database inside them. Edge, air-gapped, on-prem.
- Teams stranded by an embedded graph DB going away. Cypher-compatible, so the port is short.
- Anyone whose graph is the product, and whose margins are the engine's.
Stay close to the build
Tell us who you are.
We're opening TETRA up slowly, and we'd like to know who's out there. Tell us what you're working on and we'll keep you in the loop as we get closer to launch. If it turns out we're a good fit for each other, there may be more to talk about.
Join the waitlist
Tell us who you are and what you're working on. It takes about a minute, and a real person reads it.