Databases

Open Beta
Open Beta

Managed databases are available to every account — create one from the Databases tab in the console. Behavior, limits, and pricing may change before GA.

A managed database is a database Forte runs for you. It belongs to a Project, and every Service in that Project can connect to it. You don't provision a server, install a database engine, hand around credentials, or configure TLS.

Managed databases are not covered by GA service commitments unless a written order form says otherwise. Review feature maturity before using them for a production dependency.

What Forte manages for you

  • Provisioning: shared-tier databases are ready in under 30 seconds.
  • Credentials: Forte manages credentials and token rotation automatically for each Service that you connect to the database.
  • Connection wiring: connecting a database to a Service sets the environment variables your code already reads, then redeploys the Service.
  • Encryption: your data is encrypted at rest and in transit.
  • Backups: Forte backs up shared databases once a day. Dedicated databases add point-in-time restore (7-day default retention). See Backups and restore.
  • Monitoring: storage, connection, and query metrics, plus a slow-query list, in the console.

Which engines are available

  • PostgreSQL — relational, full SQL, the default.
  • MongoDB-compatible (closed alpha) — a document database that speaks the MongoDB wire protocol, so mongosh, Compass and every MongoDB driver work unchanged. Request access from the engine tile when you create a database.

Both engines run on the shared tier with the same storage sizes, the same connection limits and the same prices. A few MongoDB features aren't available yet: multi-document transactions, sharding commands, change streams, and server-side roles (every database user has full access to its own database). The aggregation pipeline and TTL indexes work; expired documents are removed about once a minute.

Choose a tier

Forte offers two tiers. You create either one yourself in the console. Dedicated databases are in closed alpha: request access from the Dedicated tile when you create a database.

SharedDedicated
How you get itCreate it in the consoleCreate it in the console (closed alpha)
ComputeShared with other databases on the same clusterYour own server: 1, 2, or 4 vCPU with 4, 8, or 16 GB of memory
StorageYours, 1–10 GB (2 GB default)10 GB up to 100 GB, 500 GB, or 1 TB depending on size. Grows online, never shrinks
PerformanceBest effort, no uptime SLACapacity reserved for you
BackupsDailyPoint-in-time restore (7-day default retention)
MaintenanceHandled by ForteWeekly window you can change
High availabilityNot offeredSingle node. High availability: contact us
Scale to zeroBy defaultNot supported
PricingPay for what you use$51, $102, or $204 per month, plus storage

When to choose shared

Choose shared when:

  • You're prototyping, building, or running a production app with steady, low load.
  • You'd rather pay for the storage you provision and the query time you use than reserve capacity up front.

On the shared tier your database runs on a cluster alongside other Forte customers. The storage is yours alone, but the compute is shared. Forte rate-limits and throttles noisy neighbors, but the performance of your queries can still be inconsistent due to traffic from other Forte customers.

When to choose dedicated

Choose dedicated when:

  • Your workload needs predictable performance under heavy or spiky load.
  • You need isolated capacity rather than a shared cluster.
  • You need point-in-time restore.
  • Compliance rules out shared infrastructure.

Pick a size when you create the database:

SizevCPUMemoryGood for
Medium14 GBEarly production: one app, under about 1,000 daily users, light background jobs
Large28 GBGrowing apps with about 1,000 to 20,000 daily users, steady traffic, queues, and cron jobs
XLarge416 GBEstablished apps with 20,000+ daily users and heavier queries or reporting

You can change the size later. A resize restarts the database, which takes about 2–5 minutes of downtime. Storage can grow but can't shrink, and can change once every 6 hours.

Each dedicated database is a single node. Forte runs planned maintenance, such as patching, during a weekly window; the console assigns one and you can change it on the edit page. For high availability (a standby replica with automatic failover), contact us.

A dedicated database has two endpoints: a pooled one and a direct one. See Pooled or direct? for which to use.

Pooled or direct?

A dedicated PostgreSQL database has two ports. The console shows both on the database's overview page.

PortUse it forKeep in mind
Pooled (6432)App trafficConnections go through a connection pooler that hands out a server connection per transaction. Turn off server-side prepared statements, and don't rely on session state between transactions.
Direct (5432)Migrations, LISTEN/NOTIFY, advisory locks, long sessions, pg_dumpEvery client holds its own server connection, which counts against the database's max connections.

To give a service both, map a direct connection string variable when you connect the database, next to the regular connection string. In the CLI, pass --direct-connection-string-var. Forte fills it with the same format as the pooled connection string, pointed at the direct port.

Prisma reads both URLs from its datasource block:

prisma
datasource db {
  provider  = "postgresql"
  url       = env("DATABASE_URL")
  directUrl = env("DIRECT_URL")
}

Map DATABASE_URL as the connection string with the Prisma format, and DIRECT_URL as the direct connection string. Prisma Migrate then runs over the direct port while your app's queries use the pool.

For Flyway, Alembic, Rails, or any other migration tool, point the migration tool at the direct URL and keep the app on the pooled one.

Backups and restore

Forte backs up every database for you. What you can restore depends on the tier.

Shared databases get one backup a day, kept for 7 days. To restore one, contact support.

Dedicated databases get a daily backup plus continuous archiving of every change between backups. You can restore to any second inside the restorable window. The window ends at the most recent archived change. It starts 12 hours inside your retention period, so 7-day retention reaches back 6.5 days. A newer database starts at its first backup instead. If the server fails, you lose at most about a minute of the latest writes.

  • Retention: 1 to 35 days, 7 by default. Change it on the database's edit page. Longer retention keeps more backup data, and backup storage beyond the database's provisioned storage size is billed.
  • A restore creates a new database. The source database keeps running and doesn't change. The new database has the source's data and database users, and each user keeps its password. Service connections stay with the source: connect your services to the new database, then disconnect them from the old one.
  • Deleted databases stay restorable for their retention period. Find them under Recently deleted on the Databases page, or run forte databases deleted.

Restore a dedicated database

From the console:

  1. Open the database and choose the Backups tab. For a deleted database, open Recently deleted on the Databases page instead.
  2. Choose Restore… and pick a time, or open a backup's menu and choose Restore this backup.
  3. Name the new database, check its size and storage, and choose Restore Database. The new database needs at least as much storage as the source holds; the console picks a size that fits.

The restore runs in the background, and larger databases take longer. The new database's page shows the source and the restore time.

From the CLI, list the backups and the restorable window, then create the new database from one of them:

bash
forte databases backups <projectId> <databaseId>
forte databases create <projectId> orders-db-restored --restore-from <databaseId> --point-in-time 2026-10-15T14:03:00Z

Use --backup-id <id> instead of --point-in-time to restore a specific backup. Give the time in ISO-8601 with a zone; Z means UTC.

What it costs

Shared databases — PostgreSQL or MongoDB-compatible — bill on the same two rates:

  • Storage: $0.50 per provisioned GB, per month. You pay for the size provisioned, not the bytes you wrote.
  • Active compute: $0.20 per vCPU, per hour, charged only while the database processes queries.

Bulk discounts apply when active compute exceeds 30% of monthly capacity. Contact us for pricing.

Dedicated databases bill a flat monthly price for the size you pick, plus storage:

  • Medium (1 vCPU, 4 GB): $51 per month.
  • Large (2 vCPU, 8 GB): $102 per month.
  • XLarge (4 vCPU, 16 GB): $204 per month.
  • Storage: $0.20 per provisioned GB, per month.
  • Backup storage: included up to your provisioned storage size, then $0.05 per GB, per month.

See Pricing and quotas for worked examples and per-account limits.

Next steps

Search

Search your resources, console pages, and documentation