# Lathe — managed Postgres 17 with the storage included

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://app.lathe.computer/

## What it is
- Managed PostgreSQL 17. Each customer gets a dedicated instance (its own CPU, RAM and local NVMe disk), not a schema in a shared cluster.
- 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; beyond that, a conversation, not a bill.
- Region: EU — Germany or Finland, chosen per instance when it is created.
- Operator: Lathe. Support by email, support@lathe.computer, replies within 24 hours.

## Plans (USD per month, billed monthly in advance; every plan starts free for three days, no card needed to create)
plan      vCPU  RAM     storage   price   per GB
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
- Free start: an instance is created without a card and runs for three days. Adding a card within those three days keeps it; otherwise it is reclaimed and its data deleted.
- 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.
- 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, seven 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 seven 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: create, restore, reset (wipe and re-initialise), rotate credentials, IP allowlist, resize up, delete (a final snapshot is kept seven days).
- Patching: Postgres 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, seven 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: Germany or Finland (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: an API key created on the portal's Account page (https://app.lathe.computer/account), sent as `Authorization: Bearer lathe_…`. A key acts as the customer who made it and cannot create or revoke keys.
- MCP server (Streamable HTTP): https://app.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, get_job. Claude Code: `claude mcp add --transport http lathe https://app.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, 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, 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. Enter an account name and choose a plan. No card is needed to create the instance.
3. About 90 seconds later the portal shows the instance with its connection strings.
4. Add a card within three days to keep the instance; otherwise it is reclaimed and its data deleted.
5. Connect with any PostgreSQL client. pg_dump works against the instance at any time; there is no proprietary layer.

## 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
- 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.

## Comparison, 4 GB RAM class (vendor list prices checked 2–3 September 2026; euro at 1.10 USD/EUR; verify before quoting)
provider                       storage   price/mo  per GB   backups
Lathe Starter                  40 GB     $29       $0.73    daily, 7 kept
Ubicloud hobby-2               32 GB     $39       $1.22    point-in-time
AWS RDS db.t4g.medium          40 GB     ~$52      $1.30    point-in-time (us-east-1, single-AZ, on-demand, gp3)
DanubeData Matita              50 GB     EUR 50    $1.10    daily
DigitalOcean Basic 4 GiB       60 GB     $61       $1.02    point-in-time
Galaxy Cloud Pro               30 GB     $69.50    $2.32    not stated
Supabase Pro + Medium compute  8 GB      $75       $9.38    PITR costs $100 extra
Render 2 CPU / 4 GB            40 GB     ~$87      $2.17    point-in-time (1 GB included, then $0.30/GB)
Neon Launch, 1 CU always-on    metered   ~$77      n/a      point-in-time
Nebius Managed PostgreSQL has no 4 GB size; its smallest preset is 2 vCPU / 8 GB at about $105 with 40 GiB.

## Traffic, 4 GB RAM class (included outbound allowance per month, then overage; checked 3 September 2026)
provider                       included            then
Lathe Starter                  20 TB               a conversation, not a bill
Ubicloud hobby-2               0.625 TB (VM quota) $3 per TB
AWS RDS db.t4g.medium          100 GB, account-wide $0.09 per GB
DanubeData Matita              1 TB                EUR 1 per TB
Supabase Pro + Medium compute  250 GB              $0.09 per GB
Render 2 CPU / 4 GB            25 GB, per workspace $0.15 per GB
Neon Launch, 1 CU always-on    500 GB              $0.10 per GB

## 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.

## Legal
- Terms: https://app.lathe.computer/terms
- Data processing agreement, which names the infrastructure subprocessor: https://app.lathe.computer/dpa