connection pool
A set of already open database connections that a program reuses instead of opening a new one for each request.
In more detail
Opening a connection to a database server takes time and memory on the server, so applications keep a pool and borrow a connection per unit of work. Without pooling, many short requests can exhaust a small database before its processor is busy.
Example
RDS Proxy pools connections for many short-lived clients such as Lambda functions.Related terms
- Amazon RDS — Amazon Relational Database Service, which runs relational database engines such as PostgreSQL and MySQL as a managed service.
- Lambda concurrency — How many copies of a function are running at the same moment, which Lambda caps with an account and optional per-function quota.
- database — A program that stores data in an organised way and answers questions about it, such as PostgreSQL.
- multi-tenancy — One running system serving several separate customers, called tenants, while keeping each one's data and settings apart.
- row-level security — A database feature that filters which rows each query may see or change, using policies the database enforces itself.
- graceful shutdown — Stopping a service in an orderly way: finish current work, close connections, then exit.
- database driver — The library that lets a program connect to and talk with a particular database.
- serverless — A way of running code or services where the provider manages all the servers and you pay only while work is being done.
- transaction — A group of database changes that succeed or fail together, so the data is never left half-updated.
- connection — An open session between a program and a database, through which it sends statements and receives results.
- database server — A database that runs as its own long-lived program and serves many client programs over network connections.
- thread pool — A fixed or bounded set of reusable worker threads that take tasks from a queue, instead of creating a new thread for each task.
- Little's law — A rule from queueing theory: average lead time equals average work in progress divided by average throughput.
- saturation — How full a system’s most constrained resource is, such as its CPU, memory, connections or queue.
Taught in
- Serverless Compute (Lambda) — Cloud Infrastructure & Hyperscaler Architecture
- Managed Relational Databases (RDS) — Cloud Infrastructure & Hyperscaler Architecture
- Multi-Tenant Identity: Tenant Isolation & Middleware — Production Full-Stack Engineering
- Health Probes & Graceful Shutdown: Kubernetes Lifecycles — Production Full-Stack Engineering
- Runtime Environments: Node.js vs Edge Runtime Choice — Next.js 15 & Modern App Router Architecture
- Instrumentation: OpenTelemetry & Performance Spans — Next.js 15 & Modern App Router Architecture
- Close Phase & Signal Dispatch: Sockets & Teardown — Node.js Internals & Backend Services
- Production Hardening: Graceful Shutdown & Docker — Node.js Internals & Backend Services
- Where PostgreSQL Differs From SQLite — PostgreSQL, Indexing & Relational Data Modeling
- Timeouts, And Avoiding Cascaded Failure — Scalable System Design & Distributed Architecture
- Observability As A Design Input — Scalable System Design & Distributed Architecture
- Worked Design One: Scaling The Ticket Booking System — Scalable System Design & Distributed Architecture