The product, in plain text.

# Lathe — your own data infrastructure, run for you (Postgres 17, Redis 8, CouchDB 3 and NATS 2 on one dedicated machine, one flat price)

This document is for AI agents and LLM-based tools. It states what Lathe sells, what it costs, what is and is
not included, and how a database is obtained, in plain text with no marketing. The page for people: https://lathe.computer/

## What it is
- Positioning: best value for money for solo builders and small teams — the whole machine a VPS would give you, run by Lathe like a managed platform would, with nothing metered. Not a fit for workloads that need read replicas, failover, point-in-time restore or a region outside the EU.
- Managed Postgres 17, Redis 8, CouchDB 3 and NATS 2. Each customer gets a dedicated instance (its own CPU, RAM and local NVMe disk), not a schema in a shared cluster. An instance runs any subset of the engines; each engine has a memory budget out of the plan's RAM (15% is kept for the system) that the customer can change.
- Postgres 17 (relational sql database; PostgreSQL): the SQL database, with PgBouncer on 6432; port 5432 direct, 6432 pooled, TLS required. Standard, rock-solid; pgvector and the usual extensions.
- Redis 8 (cache and real-time; AGPL-3.0): cache, queues and sessions; JSON, search and time series built in; port 6379, TLS required. In-memory speed; append-only log for durability.
- CouchDB 3 (nosql document store; Apache-2.0): JSON documents over HTTPS, with replication and Mango queries; port 6984, TLS required. Erlang engine; tiny idle footprint; sync-friendly.
- NATS 2 (messaging and streams; Apache-2.0): pub/sub, request-reply and JetStream persistent streams; port 4222, TLS required. Go single binary; queues and event streams.

- Storage and outbound traffic are included in a flat monthly price. Nothing is metered: no storage, egress, connection or request charges. 20 TB of outbound traffic a month is included; above that we contact you first, and there is no automatic overage charge.
- Region: EU — Finland or Germany, chosen per instance when it is created.
- Operator: Lathe. Support by email, support@lathe.computer, replies within 24 hours on business days.
- Trial: Mini starts with a 3-day free trial — the card is verified on the hosted page (a temporary $1 authorisation that is released), nothing is charged, and the first month is charged when the trial ends unless the instance was deleted before then. One trial per person. No free tier. No refunds except where the law requires.

## Plans (USD per month, billed monthly in advance; the first month is paid when the instance is created, except Mini, which starts with a 3-day trial; every plan includes 20 TB of outbound traffic a month)
plan      vCPU  RAM     storage   price   per GB
mini      1     2 GB    20 GB     $15     $0.75  
starter   2     4 GB    40 GB     $29     $0.73  
plus      4     8 GB    80 GB     $49     $0.61  
pro       8     16 GB   160 GB    $89     $0.56  
- Mini runs on the same machine as Starter, held to its plan size by the instance itself (CPU quota, memory limit, disk guard); upgrading to Starter lifts the limits in place, the engines restart once, nothing moves.
- First payment: the first month is paid on a hosted card page when the instance is created; the card is kept for the monthly renewals. Mini: the page verifies the card instead, and the first month is charged automatically after 3 days unless the instance was deleted (a trial's first charge counts as the first renewal below). A discount code from an invitation reduces the first payment only. New accounts may run one instance until their first monthly renewal succeeds.
- Cancelling: delete the instance from the portal (or API/MCP); billing stops and a final snapshot is kept 7 days. Failed renewals are retried on days 1, 3 and 7, connections are blocked after 7 days, and the instance is deleted after 21 days.
- Plans move up only. Upgrading grows the disk permanently; there is no downgrade.
- More storage means the next plan. There is no storage add-on.

## Included in every plan
- PostgreSQL 17 with pgvector, pg_stat_statements, pg_trgm and pgcrypto available.
- PgBouncer connection pooling in transaction mode on port 6432; direct Postgres on port 5432.
- Redis: password on the default user, append-only persistence fsynced every second, noeviction. CouchDB: single node, HTTPS with basic auth as admin, every request authenticated. NATS: one user, TLS required, JetStream on local disk.
- Engines are chosen per instance, any subset; at least one is on. An engine switched off is stopped with its data kept on disk and comes back when switched on.
- TLS required on both ports; scram-sha-256 authentication; one database owner role.
- Optional IP allowlist (a per-instance firewall). Default is open to the internet with TLS and scram.
- Daily full-disk backups, 7 kept. Any of them can be restored in place from the portal: same address, so connection strings keep working. A snapshot is taken before every restore and kept 7 days, so a restore can itself be undone.
- Monthly automated restore verification: a throwaway server is built from the latest backup, pg_amcheck and a row-count sample run against it, then it is destroyed.
- Self-serve actions in the portal, the REST API and MCP: create, restore, reset (wipe and re-initialise), rotate credentials, IP allowlist, resize up, delete (a final snapshot is kept 7 days); per engine: memory budget, on/off, settings, restart, reset; inside the engines: Postgres databases and extensions, a Redis key browser and console, CouchDB databases and Fauxton, NATS JetStream streams.
- Monitoring on the instance page: CPU, memory, disk, network, per-engine figures and per-engine traffic over 1 h, 24 h and 7 d. Webhooks: every event about an instance posted to the customer's https endpoints, signed, retried.
- Patching: every engine's minor versions and OS security updates in a fixed window, Sundays 03:00 UTC, announced by email beforehand.
- Disk protection: email and portal banner at 80% full; at 95% the instance becomes read-only until it is upgraded or space is freed. It never fills to zero.

## Scope
- Backups are daily full-disk images, 7 kept; a restore uses any of them, and the restore point is that image. Point-in-time restore is not offered.
- One instance per database, restarted automatically if it stops answering. Read replicas are not offered.
- Fully managed: no shell or SSH, no superuser, no custom postgresql.conf, no untrusted extensions. Reset and restore are the recovery tools.
- Datacenters: Finland or Germany (EU), chosen when the instance is created.
- Sign-up happens in the web portal: sign-in is a magic link sent by email, so an agent that can read a mailbox and drive a browser can open an account itself. Instance management is available three ways with the same rules: the portal, a REST API and an MCP server (below).

## API and MCP (for agents and code)
- Credential: either OAuth (the MCP endpoint's 401 points at its authorization server; dynamic client registration and PKCE, the customer signs in with the email link and approves — this is what Claude.ai custom connectors do), or an API key created on the portal's Account page (https://app.lathe.computer/account), sent as `Authorization: Bearer lathe_…`. Either acts as the customer and cannot create keys or connect other apps.
- MCP server (Streamable HTTP): https://mcp.lathe.computer/mcp — tools: list_plans, get_account, update_account, get_billing, list_instances, get_instance, get_connection_urls, create_instance, update_instance, set_allowlist, rotate_password, set_sql_console, upgrade_instance, list_backups, restore_backup, reset_instance, delete_instance, configure_engines, get_job. Claude Code: `claude mcp add --transport http lathe https://mcp.lathe.computer/mcp --header "Authorization: Bearer lathe_…"`.
- REST API: https://app.lathe.computer/api/v1 (OpenAPI at https://app.lathe.computer/api/v1/openapi.json, docs at https://app.lathe.computer/api/v1/docs). GET /instances, POST /instances, GET /instances/{id}, GET /instances/{id}/connection, PUT …/allowlist, PUT …/engines, POST …/actions/{rotate|resize|reset|restore}, DELETE /instances/{id}?confirm=ID, GET /jobs/{id}, GET /me, GET /plans, GET /billing.
- Creating an instance through the API or MCP returns a checkout URL for a paid plan; a person opens it in a browser and pays (on Mini: verifies the card, and the response says `trial: true`), and the instance is provisioned when the payment page returns (poll the instance: awaiting_payment → pending → creating → running; payment_failed or error otherwise). Destructive operations (reset, restore, delete) require `confirm` equal to the instance id. Slow operations return a job id; one job per instance runs at a time.
- Documentation for people: https://app.lathe.computer/developers

## How a database is obtained
1. Sign in at https://app.lathe.computer/login — magic link by email, no password. A person or an agent.
2. Add a name on the Account page (it goes on receipts), then choose a plan, a location and optionally a name and tags for the instance.
3. Pay the first month on the hosted card page (on Mini: verify the card, nothing is charged); the browser is sent back to the portal and the instance is created.
4. About 90 seconds later the portal shows the instance with its connection strings, which are also emailed.
5. Connect with any PostgreSQL client. pg_dump works against the instance at any time; there is no proprietary layer.
Through the API or MCP the same steps are: create an API key on the Account page, call create (the name must already be set), open the returned checkout URL in a browser and pay (or verify the card, for a trial), then poll the instance until it is running.

## Connection details
- Host: ID.db.lathe.computer, assigned per instance. Ports: 6432 pooled, 5432 direct.
- Connection string shape: postgres://USER:PASSWORD@ID.db.lathe.computer:6432/DB?sslmode=require
- Redis URL shape: rediss://default:PASSWORD@ID.db.lathe.computer:6379 (TLS; the port opens only when the engine is on)
- CouchDB URL shape: https://admin:PASSWORD@ID.db.lathe.computer:6984/ (TLS; the port opens only when the engine is on)
- NATS URL shape: tls://app:PASSWORD@ID.db.lathe.computer:4222 (TLS; the port opens only when the engine is on)

- Use port 5432 for anything that needs a session: LISTEN/NOTIFY, session-level SET, advisory locks held across transactions, prepared statements reused across transactions. Transaction-mode pooling on 6432 does not preserve those.
- Credentials: one owner role with a generated password. Rotate it from the portal; the pooler reloads without downtime.

## Typical uses
- Embeddings and pgvector stores, analytics and reporting databases, scraped and imported datasets, logs and events, side projects and internal tools, development and staging environments — anywhere storage volume matters more than a metered bill.
- Beside Postgres on the same instance: Redis for caches, sessions and rate limits; CouchDB for JSON documents and offline-first sync; NATS for queues, events and request-reply between services — one machine, one bill, no second vendor.

## Legal
- Terms: https://lathe.computer/terms
- Data processing agreement: https://lathe.computer/dpa
- Subprocessors (part of the DPA): https://lathe.computer/subprocessors