// postgres
No account, key, or license.
Community Edition runs on Postgres and pgvector in Docker Compose. Your data stays in a local volume.
// the retrieval gateway
Start on Postgres. Scale on Turbopuffer.
A retrieval gateway with the same API on your laptop and in production, and caching, embedding, transforms, and cost controls on top.
Pro is free for 30 days, with no credit card or sales call. Community Edition runs on your laptop with Postgres.
# open source
Run Layer on your laptop.
Clone the repo and start the whole stack with Docker Compose: the gateway, Postgres with pgvector, and nothing to sign up for.
git clone https://github.com/hev/layer.git
cd layer
docker compose up -d --wait
curl localhost:8080/health// turbopuffer wire
Same requests, either backend.
Layer speaks the Turbopuffer API. Export a Turbopuffer key and the same gateway fronts your account.
// source available
The source is on GitHub.
The gateway, CLI, and Compose stack are on GitHub under the Business Source License 1.1.
# layer run
Experiment faster in production.
Ever needed to backfill your production data? With Layer that's as easy as building a docker container — Layer handles the compute and backfills as much of your index as you specify.
$ layer run -f udf.yaml --index products
✓ submitted product-tags
→ watching 142 rows · 0 failed · 8 rows/s
→ watching 1,284 rows · 0 failed · 11 rows/s
→ watching 4,510 rows · 0 failed · 13 rows/s
✓ complete · 12,840 rows · 23s · 0 failedYou build and push your container to the configured registry. Layer handles queueing and scaling semantics for you, while you track progress. No Kubernetes experience necessary.
# jobs to be done
Your search team's jobs to be done.
Search teams need to solve many of the most complex and expensive jobs to be done in your org's data platform. Most of them have nothing to do with making search better for users.
// ship embeddings
Ship Python. Layer runs the GPU pool.
Building CUDA images, writing Kubernetes autoscalers, managing Spark — the time sink every search team underestimates, and managed services trade one kind of pain for another. Layer collapses it: declare a Python UDF and layer runs the work on CPU or GPU, scaling pods and nodes between bursts.
// stay consistent
Track every state change your index makes.
Keeping the index in sync with source data usually means hand-rolled watchers and event hooks glued together by the team that wrote them. Layer ships the operator: it scans the index for consistency, watermarks state changes, and rolls up facets your application can read directly.
// serve fetches
A doc cache deep enough to forget about.
Whether it's a near-bottomless queue for building your pipeline, or serving full datasets from a pull-through cache, your search system needs O(1) read/write capabilities. Layer ships a production-hardened document cache tuned for high-throughput fetches.
// see search
Metrics, traces, clickstream, alerts — without the plumbing.
Observability in 2026 has plenty of options and still demands plumbing. Layer bundles clickstream from the doc cache and operational metrics from the gateway into an opinionated dashboard, backed by a PromQL-compatible time series.
// scope access
Scoped access without writing the auth proxy yourself.
Today every search team inside a multi-tenant product writes the auth proxy themselves: scope credentials to namespaces, gate the write paths, ship audit events somewhere security will accept. Layer ships scoped credentials, per-namespace RBAC, and an audit feed — the pattern your security team always asks for, as a primitive.
// track cost
Know exactly how much you're spending on search.
Today "what does search cost us per million docs" is a question nobody can answer in under a week. AWS line items live in one bill, turbopuffer in another, GPU pool minutes nowhere obvious. Layer pulls every line item into one invoice and derives the unit metrics — cost per million docs, cost per TiB indexed, cost per query — that scrub with the timeframe.
# vector systems
Built for Turbopuffer. Starts on Postgres.
Layer Pro runs in front of Turbopuffer, wire-compatible with the client you already use. Community Edition adds Postgres with pgvector, so the same requests work on a laptop.
# try it now
Try Layer Pro free for 30 days.
Enter your email, get your trial key, and install Layer in your AWS account. No credit card or sales call necessary.
// start your free trial
The trial key and install instructions arrive by email.
# what's in the box
hev layer is a BYOC product installed with Terraform and Helm. Read the Docs.
- Gateway
- Rust gateway that stays wire-compatible with your turbopuffer path while adding the read-path machinery your client doesn't have.
- Kube Operator
- Kubernetes operator owning index consistency, snapshots, and per-workload autoscaling.
- Dashboard
- Operator console for click-ops and fin-ops — namespaces, snapshots, jobs, cost in one place.
- Clients
- Python, Go, and TypeScript SDKs for teams bringing Layer into existing search code.
- License
- Trial and commercial keys install through Helm, expose health through /v2/license, and degrade through licensed, grace, and floor states.
See the docs for the full SBOM.