Relational SQL.
Managed Postgres-compatible SQL with HA, read replicas, backups and point-in-time restore.
A fully managed, Postgres-compatible relational database with high availability, automated backups and effortless scaling of reads — so your team writes queries, not failover runbooks.
- Category
- Databases
- Deployment
- Managed → air-gapped
- Governance
- IAM · encryption · audit
Managed Postgres is table stakes. Where it sits is the differentiator.
Every cloud will run Postgres for you with HA, backups and replicas — that part is solved and Aether does it the same way: synchronous replicas with sub-minute failover, cross-region read replicas, and continuous backup with point-in-time restore. Your SQL, extensions and drivers work unchanged. The question that actually shapes your architecture is what's next to the database — and here, it's the vector store and the model.
Operated for you, compatible with everything you have.
It's Postgres-compatible, so the ORM, the migrations and the dashboards you already run keep working. HA failover, read scaling and PITR are handled, so the database stops being a thing you operate and becomes a thing you use. Encryption at rest and in transit is on by default, with customer-managed keys when you need them.
Next to the vector store and the model — no cross-vendor hop.
The reason this matters: a modern app's transactional data, its embeddings and its model calls usually live in three different places, stitched together with code and crossing boundaries that have to be secured and reconciled. On Aether they're one platform — a transactional row, its vector neighbour and a model inference are reachable in one query under one identity. The relational database isn't an island; it's part of the same governed estate as the AI.
One query that reads a transactional row, finds its nearest neighbours in the vector store, and asks the model — across what would normally be three systems.
SELECT o.id, o.summary,
AETHER.GENERATE('suggest next action', o.summary, sim.cases) AS action
FROM orders o
CROSS JOIN LATERAL (
SELECT ARRAY_AGG(c.text) AS cases FROM cases c
ORDER BY VECTOR_DISTANCE(c.embedding, o.embedding) LIMIT 5
) sim
WHERE o.status = 'flagged';The transactional rows, the vector search and the model call are one statement under one identity. On RDS plus a separate vector vendor plus an external model API, this is a pipeline you build, secure and pay egress on.
Three steps to running.
A managed, Postgres-compatible instance with HA and backups configured.
Use standard drivers and extensions; the model and data sit on one platform.
Add read replicas across regions; point-in-time restore protects throughout.
Relational SQL, in full.
Use the SQL, extensions and drivers you already know.
Synchronous replicas with automatic, sub-minute failover.
Scale reads horizontally across regions.
Continuous backup with point-in-time restore to any second.
Provision it in a few lines.
Every service is reachable from the same SDK, CLI and infrastructure-as-code — one identity, one bill, one audit trail across the whole catalog.
import { aether } from "@aether/sdk";
// Provision relational sql and query it
const relational_sql = await aether.databases.create({
service: "relational-sql",
name: "app",
region: "us-1",
});
const rows = await relational_sql.query(`select * from events limit 10`);At a glance.
- Engine
- Postgres-compatible
- HA
- Sync replicas, sub-minute failover
- Reads
- Cross-region replicas
- Backup
- Continuous PITR
- Extensions
- Standard ecosystem
Built for real work.
Transactional applications
Multi-tenant SaaS backends
Systems of record
On one model, not stitched together.
The usual stack runs relational sql in one product, the model in another and the data in a third — and the seams between them are the cost. Aether Cloud runs it on the same platform that serves the model, governs your identity and deploys into your boundary, with the rest of the catalog one hop away.
No stitching a vector DB to one place, a warehouse to another and a model to a third — relational sql sits next to the rest of the catalog, one identity, one bill.
The provider that runs Aether runs your relational sql — so the data and the model never leave the same governed boundary to talk to each other.
Need a capability that isn’t here yet? The model writes and deploys it into the same boundary — the catalog is a starting point, not a ceiling.
Good to know.
Managed Postgres-compatible SQL with HA and PITR — next to the vector store and the model, no cross-vendor hop.
Postgres-compatible — your SQL, extensions and drivers work unchanged.
Synchronous replicas with automatic, sub-minute failover.
Your boundary, your choice.
Pairs well with.
Elastic document and key-value stores for low-latency, high-throughput workloads.
Managed embeddings and similarity search at scale — the retrieval layer under grounded apps.
Purpose-built time-series storage for telemetry, metrics and sensor streams.
Sub-millisecond managed cache for sessions, hot data and rate limiting.
A property-graph database for relationships, knowledge graphs and path queries.
Columnar, separation-of-storage-and-compute warehouse for analytics at scale.
Run Relational SQL on Aether Cloud.
Managed Postgres-compatible SQL with HA, read replicas, backups and point-in-time restore. Deployable managed, in your VPC, on-prem or fully air-gapped — talk to us about the configuration your workloads and your boundary require.