# Heroku Postgres: Plans, Pricing, Setup, and Alternatives in 2026
> Heroku Postgres plans, pricing, supported versions, setup for Django, Node.js and Python, PgAdmin access, and the best alternatives in 2026.
- **Author**: parth-kanpariya
- **Published**: 2026-04-18
- **Modified**: 2026-04-18
- **Category**: Deployment Guides
- **URL**: https://kuberns.com/blogs/heroku-postgres/
---
If you're building on Heroku and need a production-ready PostgreSQL database, Heroku Postgres is the path of least resistance. It's a managed add-on that provisions in one CLI command, injects the connection string automatically, and handles backups, SSL, and version upgrades without any infrastructure setup from your side.
But "managed" doesn't mean cheap, and it doesn't mean unlimited. The jump from the Essential tier ($5/month, 99.5% uptime) to the Standard tier ($50/month, 99.95% uptime) is significant. Connection limits on Essential databases can bite you in production. And once you start adding database costs on top of dyno costs, Heroku's bill grows faster than expected.
This guide covers everything you need to know about Heroku Postgres in 2026 — plans, pricing, supported versions, how to set it up, how to connect from Django, Node.js, and Python, how to access it with PgAdmin, and what alternatives to consider when Heroku's pricing stops making sense.
## What Is Heroku Postgres?
Heroku Postgres is a managed database-as-a-service add-on built directly into the Heroku platform. It runs unmodified PostgreSQL — currently supporting versions 15, 16, and 17 — on managed infrastructure backed by AWS.
When you provision a Heroku Postgres database, Heroku handles:
* Server provisioning and OS maintenance
* Write-ahead log (WAL) backups every 60 seconds
* Daily logical backups via PG Backups (free, optional)
* Automatic minor version upgrades (on Standard tier and above)
* SSL-encrypted connections
* A web dashboard for monitoring and Dataclips
You interact with your database the same way you would with any PostgreSQL instance — using the connection string Heroku injects as a `DATABASE_URL` config var.
## Heroku Postgres Plans and Pricing in 2026
Heroku Postgres plans are grouped into five tiers. The tier determines uptime SLA, available features, and price.
### Heroku Postgres Plan Tiers
| Tier | Monthly Downtime Tolerance | Starting Price | HA | Fork & Follow | Rollback |
|---|---|---|---|---|---|
| Essential | Up to 4 hours/month | $5/mo | No | No | No |
| Standard | Up to 1 hour/month | $50/mo | No | Yes | 4 days |
| Premium | Up to 15 min/month | $200/mo | Yes | Yes | 1 week |
| Private | Up to 15 min/month | $300/mo | Yes | Yes | 1 week |
| Shield | Up to 15 min/month | $350/mo | Yes | Yes | 1 week |
All tiers include disk encryption, SSL access, daily backups, Dataclips, and the Heroku Postgres dashboard.
### Essential Tier Plans
The Essential tier is intended for development, staging, and hobby projects.
| Plan | Provisioning Name | Storage | Connection Limit | Max Cost/Month |
|---|---|---|---|---|
| Essential-0 | `heroku-postgresql:essential-0` | 1 GB | 20 | $5 |
| Essential-1 | `heroku-postgresql:essential-1` | 10 GB | 20 | $9 |
| Essential-2 | `heroku-postgresql:essential-2` | 32 GB | 40 | $20 |
**Important limitations on Essential tier:**
* No fork or follow (read replicas)
* No Postgres logs
* No additional credentials
* Unannounced maintenance windows and automatic version upgrades
* 99.5% expected uptime (roughly 3.65 hours downtime/month)
* Maximum 20–40 connections — this will be a bottleneck for production apps with high concurrency
### Standard Tier Plans
| Plan | Storage | Max Cost/Month |
|---|---|---|
| Standard-0 | 4 GB RAM hot data | $50 |
| Standard-2 | 8 GB RAM hot data | $200 |
| Standard-3 | Higher | $400 |
Standard tier adds: Postgres logs, fork and follow, 4-day rollback, and 99.95% uptime SLA.
### Premium, Private, and Shield Tiers
* **Premium** ($200+/month): Adds high availability (HA) and 1-week rollback
* **Private** ($300+/month): Requires a Heroku Team account, runs in a Private Space with enhanced network isolation
* **Shield** ($350+/month): Adds compliance capabilities (HIPAA, PCI) for regulated workloads
The full plan list runs to over 50 SKUs. You can view all current pricing at [elements.heroku.com/addons/heroku-postgresql](https://elements.heroku.com/addons/heroku-postgresql).
### The Pricing Reality
The Essential tier looks affordable at $5/month — but it comes with 99.5% uptime, no HA, and only 20 connections. For any production app with concurrent users, you'll hit the connection limit fast. The jump to Standard-0 at $50/month is a 10x price increase. Add dyno costs on top and Heroku's total bill climbs quickly for growing teams.
## Heroku Postgres Versions in 2026
Heroku Postgres runs unmodified PostgreSQL. The currently supported versions are:
| Version | Status | End-of-Life |
|---|---|---|
| 15 | Available | Q3 2026 |
| 16 | Available | Q3 2027 |
| 17 | **Default** | Q3 2028 |
| 14 | Deprecated | November 28, 2025 |
| 13 | Deprecated | October 29, 2024 |
Version 17 is the default for all new databases provisioned on Heroku. Heroku supports each major version for approximately 3 years (shorter than PostgreSQL's own 5-year support cycle).
**Key version policy details:**
* Minor versions are updated automatically after maintenance windows (Standard tier and above)
* Essential tier may receive automatic major version upgrades with no warning
* If you need a specific version, use the `--version` flag: `heroku addons:create heroku-postgresql:essential-1 --version 16`
* Postgres version 15 reaches end-of-life on Heroku in Q3 2026 — if you're on v15, plan an upgrade now
To check which version your database is running:
```bash
heroku pg:info --app YOUR_APP_NAME
```
## How to Set Up Heroku Postgres
### Step 1: Provision the Database
```bash
heroku addons:create heroku-postgresql:essential-0 --app YOUR_APP_NAME
```
Replace `essential-0` with your desired plan. Heroku automatically creates a `DATABASE_URL` config var in your app.
### Step 2: Confirm Provisioning
```bash
heroku addons --app YOUR_APP_NAME
# Output: heroku-postgresql (HEROKU_POSTGRESQL_COBALT_URL) essential-0 $5/month created
heroku pg:info --app YOUR_APP_NAME
# Shows: Plan, Status, Connections, PG Version, Created
```
### Step 3: Access Your Connection String
```bash
heroku pg:credentials:url DATABASE --app YOUR_APP_NAME
```
This outputs the full `postgres://user:password@host:port/dbname` connection string.
### Step 4: Run Migrations (if applicable)
```bash
heroku run python manage.py migrate --app YOUR_APP_NAME # Django
heroku run npm run db:migrate --app YOUR_APP_NAME # Node.js with a migration tool
```
---
## Connecting Heroku Postgres to Your App
### Heroku Postgres with Node.js
Use the `pg` package (node-postgres):
```bash
npm install pg
```
```javascript
const { Pool } = require('pg');
const pool = new Pool({
connectionString: process.env.DATABASE_URL,
ssl: {
rejectUnauthorized: false // Required for Heroku Postgres connections
}
});
async function query(text, params) {
const res = await pool.query(text, params);
return res;
}
```
The `DATABASE_URL` environment variable is automatically available when your app runs on Heroku. For local development, add it to your `.env` file.
**Common Node.js error:** If you see `The authentication type 10 is not supported`, your pg driver is outdated. Upgrade to `pg` version 8.x or later.
### Heroku Postgres with Python
Use `psycopg2` as the driver:
```bash
pip install psycopg2-binary
```
```python
import os
import psycopg2
from urllib.parse import urlparse
DATABASE_URL = os.environ['DATABASE_URL']
result = urlparse(DATABASE_URL)
conn = psycopg2.connect(
dbname=result.path[1:],
user=result.username,
password=result.password,
host=result.hostname,
port=result.port,
sslmode='require'
)
```
For production Python apps, use a connection pool via `psycopg2.pool.ThreadedConnectionPool` or switch to `asyncpg` for async frameworks.
### Heroku Postgres with Django
Install the required packages:
```bash
pip install dj-database-url psycopg2-binary
```
In `settings.py`:
```python
import dj_database_url
DATABASES = {
'default': dj_database_url.config(
default=os.environ.get('DATABASE_URL'),
conn_max_age=600,
ssl_require=True
)
}
```
`dj-database-url` parses the `DATABASE_URL` environment variable automatically. The `conn_max_age=600` setting enables persistent connections (60-second pool timeout), which is important for performance on Heroku's Essential tier where connection limits are tight.
Run migrations:
```bash
heroku run python manage.py migrate --app YOUR_APP_NAME
```
> Related: [The fastest way to deploy a Django app in 2026](https://kuberns.com/blogs/how-to-deploy-django-app-in-one-click-with-ai/)
### Heroku Postgres with Python (Flask / FastAPI)
For Flask with SQLAlchemy:
```python
from flask_sqlalchemy import SQLAlchemy
import os
app.config['SQLALCHEMY_DATABASE_URI'] = os.environ.get('DATABASE_URL', '').replace(
'postgres://', 'postgresql://' # SQLAlchemy 1.4+ requires postgresql:// prefix
)
db = SQLAlchemy(app)
```
> Note: Heroku still outputs `postgres://` in the connection string. SQLAlchemy 1.4 and above require `postgresql://`. The `.replace()` call above handles this transparently.
---
## Connecting Heroku Postgres to PgAdmin
PgAdmin lets you manage your database with a GUI — useful for exploring schema, running ad hoc queries, and debugging data.
### Step 1: Get Your Connection Credentials
```bash
heroku pg:credentials:url DATABASE --app YOUR_APP_NAME
```
The output looks like:
```
Connection info string:
"dbname=dee932clc3mg8h host=ec2-123-73-145-214.compute-1.amazonaws.com port=6212 user=user3121 password=98kd8a9 sslmode=require"
```
### Step 2: Add a Server in PgAdmin
1. Open PgAdmin → Right-click **Servers** → **Register → Server**
2. Under **General**: give it a name (e.g., `Heroku Production`)
3. Under **Connection**:
- **Host**: the `ec2-...compute-1.amazonaws.com` value
- **Port**: `6212` (or the port from your credentials)
- **Database**: the `dbname` value
- **Username**: the `user` value
- **Password**: the `password` value
4. Under **SSL**: set **SSL mode** to `require`
5. Click **Save**
PgAdmin will connect and show your database schema in the sidebar.
**Note:** Heroku rotates credentials periodically. If your PgAdmin connection stops working, re-run `heroku pg:credentials:url` to get fresh credentials and update PgAdmin.
---
## Heroku Postgres Limitations to Know Before You Scale
### 1. Connection Limits Are Tight
Essential-0 and Essential-1 allow only 20 connections. If your app uses a thread-per-request model (like Django's default development server), you'll hit this ceiling fast with real traffic. Solutions:
* Use connection pooling in your app (`conn_max_age` in Django, `Pool` in node-postgres)
* Deploy PgBouncer as a sidecar connection pooler
* Upgrade to Essential-2 (40 connections) or Standard tier
### 2. Essential Tier Has No Logs
If something goes wrong with your queries on Essential tier, you have no Postgres logs to debug with. You're flying blind. Standard tier enables full Postgres logs.
### 3. No HA Until Premium Tier
High availability (automatic failover) is only available on Premium, Private, and Shield tiers — which start at $200/month. The Standard tier ($50/month) offers better uptime SLA but no automatic failover.
### 4. Forced Version Upgrades on Essential
Essential databases can receive major version upgrades during maintenance without notice. If you need control over when your database upgrades (to test compatibility first), you need Standard tier or above.
### 5. Cost Escalation
The jump from Essential-2 ($20/month) to Standard-0 ($50/month) is steep for a 10x uptime improvement. For growing startups, the combined cost of Heroku dynos + Heroku Postgres + other add-ons can easily exceed $150–200/month before you've shipped much product.
---
## Heroku Postgres Alternatives: When to Move On
If you're already evaluating alternatives — whether because of pricing, connection limits, or wanting managed Postgres bundled with your app platform — here's the landscape:
### Kuberns: App + Database in One Platform
[Kuberns](https://kuberns.com) is an Agentic AI cloud deployment platform that manages your app and database together, rather than treating your database as a separate billable add-on.
**What makes Kuberns different from Heroku Postgres:**
* Database and app deployment in a single platform — no separate add-on provisioning
* Agentic AI that detects your stack, configures database connections, and manages environment variables automatically
* No artificial connection limits at the $5–20 price point
* Full monitoring, logs, and alerting included without needing to upgrade tiers
* Save up to 40% on infrastructure costs vs. direct AWS or Heroku's Standard/Premium tiers
* Enterprise-grade uptime backed by AWS infrastructure
If your Heroku bill is growing — or if you're starting a new project and want to avoid Heroku's tier ceiling — [Kuberns](https://kuberns.com) handles the full deployment lifecycle including database, without the per-add-on pricing model.
> Related: [Heroku Pricing Breakdown and Ways to Reduce Costs](https://kuberns.com/blogs/heroku-pricing-explained/) · [Best Heroku Alternatives in 2026](https://kuberns.com/blogs/the-ultimate-guide-to-heroku-alternatives-in-2025/)
### Other Managed Postgres Options
| Platform | Managed Postgres | Starting Price | Notes |
|---|---|---|---|
| Kuberns | Yes (bundled with app) | $7/mo | Agentic AI deployment, no add-on model |
| Supabase | Yes | Free / $25/mo | Postgres + Auth + Storage; generous free tier |
| Neon | Yes | Free / $19/mo | Serverless Postgres, scales to zero |
| Railway | Yes | $5/mo | Per-usage billing; clean DX |
| Render | Yes | $7/mo | Predictable flat billing per service |
| PlanetScale | No (MySQL) | Free / $39/mo | Not Postgres — for MySQL workloads |
For developers who need pure managed Postgres without an app platform, Supabase and Neon both offer more generous free tiers than Heroku's Essential-0 with better developer tooling.
[Start a free Trial with Agentic AI Powered Deployment](https://dashboard.kuberns.com/)
---
## Is Heroku Postgres Right for Your Project?
**Use Heroku Postgres if:**
* Your app already runs on Heroku and simplicity matters more than cost optimization
* You're in early development and the Essential tier ($5–9/month) fits your needs
* You need Postgres extensions like PostGIS or full-text search that are pre-enabled on Heroku
* Your team is small and doesn't want to manage database infrastructure at all
**Consider an alternative if:**
* You're hitting Essential tier connection limits (20 connections) with real traffic
* Your combined Heroku bill (dynos + Postgres + add-ons) is approaching $100–200/month
* You need high availability without paying $200/month for Premium tier
* You're starting a new project and want to avoid Heroku's pricing ceiling from the start
The right answer depends on where you are in your project's lifecycle. For early-stage projects on Heroku, the Essential tier is a reasonable starting point. For production workloads with real traffic, the cost-to-value ratio of Heroku Postgres starts to break down against alternatives like Kuberns, Railway, and Render that bundle database hosting with competitive app deployment pricing.
> Further reading: [What Is Heroku and Is It Still Relevant in 2026](https://kuberns.com/blogs/what-is-heroku/) · [Heroku vs Railway vs Kuberns](https://kuberns.com/blogs/heroku-vs-railway-vs-kuberns/) · [How to Deploy a Django App in 2026](https://kuberns.com/blogs/how-to-deploy-django-app-in-one-click-with-ai/)
---
## Frequently Asked Questions
### Q: What PostgreSQL versions does Heroku Postgres support in 2026?
Heroku Postgres currently supports PostgreSQL 15, 16, and 17. Version 17 is the default for new databases. Versions 11–14 have been deprecated. Version 15 reaches end-of-life on Heroku in Q3 2026.
### Q: How much does Heroku Postgres cost?
Essential plans start at $5/month (1 GB storage, 20 connections). Standard plans start at $50/month with 99.95% uptime SLA. Premium plans start at $200/month and add high availability. Private and Shield tiers start at $300–350/month for compliance-capable deployments.
### Q: How do I connect Heroku Postgres to Django?
Install `dj-database-url` and `psycopg2-binary`, then set `DATABASES = {'default': dj_database_url.config(conn_max_age=600, ssl_require=True)}` in `settings.py`. The `DATABASE_URL` config var is injected automatically when you provision the add-on.
### Q: How do I connect Heroku Postgres to Node.js?
Use the `pg` package. Read `process.env.DATABASE_URL` and pass it as the `connectionString` to a `Pool`, with `ssl: { rejectUnauthorized: false }`. SSL is required for all Heroku Postgres connections.
### Q: Can I connect PgAdmin to Heroku Postgres?
Yes. Run `heroku pg:credentials:url DATABASE` to get the host, port, database, username, and password. In PgAdmin, create a new server with those credentials and set SSL mode to `require`.
### Q: What is the difference between Heroku Postgres Essential and Standard plans?
Essential plans tolerate up to 4 hours of downtime per month, have no fork/follow, no Postgres logs, and a 20-connection limit. Standard plans ($50/month+) offer under 1 hour of downtime, fork and follow support, 4-day rollback, and full Postgres logs.
### Q: How do I create a Heroku Postgres database?
Run `heroku addons:create heroku-postgresql:essential-0 --app YOUR_APP_NAME`. Heroku provisions the database and automatically adds `DATABASE_URL` to your app's config vars.
### Q: What is a good Heroku Postgres alternative?
Kuberns bundles managed PostgreSQL with app deployment in a single platform, with no separate add-on model. Other good alternatives include Supabase (generous free tier), Neon (serverless Postgres), Railway (usage-based), and Render (flat monthly pricing).
### Q: Does Heroku Postgres support connection pooling?
Heroku Postgres does not include a built-in connection pooler. On Essential tier (20-connection limit), use application-level pooling (`conn_max_age` in Django, `Pool` in node-postgres) or deploy PgBouncer as a separate add-on. Standard and higher tiers allow more connections but still benefit from pooling at scale.
### Q: How do I run Heroku Postgres locally?
Install PostgreSQL locally and create a local database. Add `DATABASE_URL=postgresql://localhost/mydb` to your `.env` file and use `heroku local` to run your app with local environment variables. Heroku recommends keeping your local Postgres version in sync with your production version to catch compatibility issues early.
---
- [More Deployment Guides articles](https://kuberns.com/blogs/category/deployment-guides/1/)
- [All articles](https://kuberns.com/blogs/)