Introducing pgdog: Rust‑Based PostgreSQL Connection Pooler and Sharding Solution

What Is pgdog? – A Quick Overview

Built on the high‑performance Rust language, pgdog acts as a smart proxy between your application and one or many PostgreSQL instances. It combines three core capabilities—connection pooling, intelligent load balancing, and automatic sharding—into a single, easy‑to‑configure service. Because it parses the PostgreSQL wire protocol, pgdog can route reads to replicas, writes to primaries, and even split data across multiple shards without any code changes on the client side.

The project is hosted on GitHub under the AGPL‑3.0 license, which means you can use it freely in production, modify it for internal needs, and contribute back to the community.

Key Features of pgdog (MECE)

1️⃣ Connection Pooling

• Supports both transaction‑level and session‑level pooling, similar to PgBouncer.
• Automatically re‑uses idle server connections, reducing the overhead of establishing new TCP sockets.
• Graceful handling of abandoned transactions with automatic rollbacks.

2️⃣ Application‑Layer Load Balancing

• Three built‑in strategies: round‑robin, random, and least‑active connections.
• Health‑check subsystem removes unhealthy replicas from rotation in real time.
• Read‑only queries are automatically sent to replicas, while writes go to the primary.

3️⃣ Automatic Sharding

• Supports hash, list, and range partitioning directly from PostgreSQL’s native partition functions.
• Schema‑based sharding lets you group tables under a common schema and route them to the same shard.
• Cross‑shard queries are executed on all relevant shards and results are merged in memory.

4️⃣ Two‑Phase Commit for Cross‑Shard Transactions

pgdog implements PostgreSQL’s 2PC protocol, guaranteeing atomicity across shards. If a client disconnects mid‑transaction, pgdog will either roll back or commit the pending phase based on the transaction state.

5️⃣ Unique ID Generation

The built‑in pgdog.unique_id() function creates globally unique BIGINT identifiers without a central sequence, supporting millions of IDs per second.

6️⃣ Monitoring & Metrics

• Exposes an OpenMetrics endpoint compatible with Prometheus, Grafana, and Datadog.
• Provides a PgBouncer‑style admin database for quick diagnostics.

Recent Updates (as of February 2026)

Since its first public release in 2023, pgdog has amassed over 3,400 stars on GitHub and is now used in production by several fintech and SaaS startups. The community contributes roughly 30 pull requests per month, indicating a healthy open‑source ecosystem.

Why Developers Choose pgdog – Benefits & Real‑World Use Cases

Performance & Cost Savings

By pooling connections and routing reads to cheaper read‑replicas, pgdog can reduce the number of required PostgreSQL server processes by up to 70 %. This translates directly into lower cloud‑instance costs, especially on AWS RDS or Azure Database for PostgreSQL.

Zero‑Code Sharding for Multi‑Tenant SaaS

SaaS platforms often need to isolate tenant data while sharing hardware. pgdog’s schema‑based sharding lets you create a separate schema per tenant, automatically directing all queries to the appropriate shard without rewriting application code.

High Availability & Automatic Failover

When a primary node fails, pgdog detects the change via replication LSN checks and instantly redirects write traffic to the newly promoted replica. This works alongside tools like Patroni for orchestrated failover, providing a layered resilience strategy.

Developer Productivity

Because pgdog speaks the native PostgreSQL wire protocol, you can keep using existing ORMs (e.g., Prisma, SQLAlchemy, TypeORM) without any driver changes. The only required change is updating the connection string to point at pgdog’s listening port (default 6432).

Compliance & Auditing

The admin database logs connection lifecycles, query routing decisions, and health‑check outcomes. Export these logs to a SIEM solution for audit trails, satisfying GDPR and PCI‑DSS requirements.

How to Get Started with pgdog

1. Clone the repository and build the binary:

   git clone https://github.com/pgdogdev/pgdog.git
   cd pgdog
   cargo build --release

2. Create configuration files (pgdog.toml and users.toml). A minimal example:

   # pgdog.toml
   [general]
   port = 6432
   default_pool_size = 15
   
   [[databases]]
   name = "mydb"
   host = "127.0.0.1"
   role = "primary"
   
   [[databases]]
   name = "mydb"
   host = "127.0.0.1"
   role = "replica"

   # users.toml
   [[users]]
   name = "app_user"
   database = "mydb"
   password = "s3cr3t"

3. Start pgdog:

   cargo run --release -- -c pgdog.toml -u users.toml

4. Connect your application using the new endpoint:

   postgres://app_user:s3cr3t@localhost:6432/mydb

For a Docker‑first workflow, the project ships a docker-compose.yml that spins up pgdog alongside three PostgreSQL containers (one primary, two replicas). This is ideal for quick local testing or CI pipelines.

Architecture Diagram

The diagram shows how pgdog sits between client applications and a pool of PostgreSQL instances, handling routing, pooling, and sharding logic.

Related UBOS Resources for Building AI‑Powered Data Pipelines

While pgdog focuses on PostgreSQL scaling, many teams pair it with AI‑centric platforms to unlock real‑time analytics. Below are UBOS solutions that complement pgdog’s capabilities:

• UBOS platform overview – a low‑code environment for deploying micro‑services, including database adapters.
• Enterprise AI platform by UBOS – integrates with PostgreSQL back‑ends for large‑scale model serving.
• AI SEO Analyzer – can ingest pgdog‑exposed metrics to suggest query‑level optimizations.
• AI Article Copywriter – demonstrates how to generate documentation directly from database schemas.
• Workflow automation studio – orchestrates ETL jobs that read from pgdog‑managed shards.
• Web app editor on UBOS – lets you build front‑ends that query pgdog without writing boilerplate code.
• AI marketing agents – can pull real‑time sales data from sharded PostgreSQL clusters.
• UBOS partner program – offers co‑selling opportunities for SaaS vendors using pgdog.
• UBOS pricing plans – transparent pricing for scaling AI‑driven services on top of pgdog.
• UBOS for startups – a fast‑track path to launch MVPs that need robust database back‑ends.

Conclusion: pgdog as a Cornerstone for Modern PostgreSQL Deployments

In the era of micro‑services and AI‑augmented workloads, the ability to scale PostgreSQL horizontally without rewriting application logic is a competitive advantage. pgdog delivers that advantage through a single binary that handles pooling, load balancing, and sharding—all while exposing rich metrics for observability.

Whether you are a startup looking to keep cloud costs low, an SMB needing multi‑tenant isolation, or an enterprise building AI pipelines on top of massive data lakes, pgdog provides a production‑ready, open‑source foundation. Pair it with UBOS’s low‑code AI platform, and you can spin up end‑to‑end data‑driven products in days instead of weeks.

Ready to try pgdog? Clone the repo, configure your shards, and watch your PostgreSQL cluster scale effortlessly.