# connection pool

Published articles for connection pool.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Cache stampede: how one expired key takes down the database

DevFeed: [Cache stampede: how one expired key takes down the database](<https://devfeed.tech/articles/cache-stampede-how-one-expired-key-takes-down-the-database-39600.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/48-cache-stampede-expired-key/>)

Author: hello@ankit-rana.com

Published: 2026-09-05T00:00:00Z

Content type: tutorial

Language: en

Sources: [Ankit Rana | Mechanical Sympathy](<https://devfeed.tech/sources/ankit-rana-mechanical-sympathy.md>)

Topics: [Cache](<https://devfeed.tech/topics/cache.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [Database](<https://devfeed.tech/topics/database.md>), [consistent hashing](<https://devfeed.tech/topics/consistent-hashing.md>), [Redis](<https://devfeed.tech/topics/redis.md>)

Tags: [cache-stampede](<https://devfeed.tech/tags/cache-stampede.md>), [caching](<https://devfeed.tech/tags/caching.md>), [connection-pool](<https://devfeed.tech/tags/connection-pool.md>), [consistent-hashing](<https://devfeed.tech/tags/consistent-hashing.md>), [distributed-systems](<https://devfeed.tech/tags/distributed-systems.md>), [jitter](<https://devfeed.tech/tags/jitter.md>), [query](<https://devfeed.tech/tags/query.md>), [redis](<https://devfeed.tech/tags/redis.md>), [reliability](<https://devfeed.tech/tags/reliability.md>), [thundering-herd](<https://devfeed.tech/tags/thundering-herd.md>), [traffic](<https://devfeed.tech/tags/traffic.md>), [ttl](<https://devfeed.tech/tags/ttl.md>)

### AI overview

This article explains how a cache stampede occurs when a hot key expires and many requests simultaneously recompute the same value against the database. It recommends TTL jitter to prevent synchronized expirations and request coalescing so only one caller recomputes while others wait or serve stale data. It also discusses cache warming and consistent hashing for broader cache-failure scenarios.

### Source excerpt

A cache TTL is a scheduled simultaneous failure: every request being served from one key misses at the same instant and goes to the origin together. If the recompute takes two seconds, every request arriving during those two seconds also misses, so the pileup grows faster than it drains. Jitter on the TTL stops keys expiring in lockstep, and request coalescing so only one caller recomputes while the rest wait or serve stale is what stops a single expensive key from saturating the database.

## Connection pool sizing is a queueing theory problem, not a tuning knob

DevFeed: [Connection pool sizing is a queueing theory problem, not a tuning knob](<https://devfeed.tech/articles/connection-pool-sizing-is-a-queueing-theory-problem-not-a-tuning-knob-39593.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/41-connection-pool-sizing-queueing-theory/>)

Author: hello@ankit-rana.com

Published: 2026-08-22T00:00:00Z

Content type: article

Language: en

Sources: [Ankit Rana | Mechanical Sympathy](<https://devfeed.tech/sources/ankit-rana-mechanical-sympathy.md>)

Topics: [connection pool](<https://devfeed.tech/topics/connection-pool.md>), [queueing theory](<https://devfeed.tech/topics/queueing-theory.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Database](<https://devfeed.tech/topics/database.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>)

Tags: [capacity-planning](<https://devfeed.tech/tags/capacity-planning.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [connection-pool](<https://devfeed.tech/tags/connection-pool.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [hikaricp](<https://devfeed.tech/tags/hikaricp.md>), [inference](<https://devfeed.tech/tags/inference.md>), [latency](<https://devfeed.tech/tags/latency.md>), [network](<https://devfeed.tech/tags/network.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [query](<https://devfeed.tech/tags/query.md>), [queueing-theory](<https://devfeed.tech/tags/queueing-theory.md>)

### AI overview

This article explains how to size a connection pool using Little's law: concurrency equals throughput multiplied by connection holding time. It argues that increasing the pool beyond the database's parallel execution capacity can move the queue, increase latency, and leave throughput flat. It also identifies excessive holding time from network round trips, N+1 queries, long transactions, and model inference calls as common causes of pool exhaustion.

### Source excerpt

Pool size follows from Little's law: concurrency equals throughput multiplied by holding time, so 500 requests per second each holding a connection for 20ms needs ten connections rather than a round number someone picked. Past the point where the database can execute requests in parallel, adding connections moves the queue rather than removing it, and latency grows while throughput stays flat. The number that actually reaches the database is the pool size multiplied by the instance count, which is usually the number nobody has calculated.

## Promotions are Proactive: The 3P Framework for Pitching Your Next Level

DevFeed: [Promotions are Proactive: The 3P Framework for Pitching Your Next Level](<https://devfeed.tech/articles/promotions-are-proactive-the-3p-framework-for-pitching-your-next-level-39583.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/31-promotions-proactive-3p-framework/>)

Author: hello@ankit-rana.com

Published: 2026-08-02T00:00:00Z

Content type: opinion

Language: en

Sources: [Ankit Rana | Mechanical Sympathy](<https://devfeed.tech/sources/ankit-rana-mechanical-sympathy.md>)

Topics: [Back end](<https://devfeed.tech/topics/backend.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [connection pool](<https://devfeed.tech/topics/connection-pool.md>), [migration](<https://devfeed.tech/topics/migration.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [caching](<https://devfeed.tech/tags/caching.md>), [career](<https://devfeed.tech/tags/career.md>), [career-growth](<https://devfeed.tech/tags/career-growth.md>), [connection-pool](<https://devfeed.tech/tags/connection-pool.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [latency](<https://devfeed.tech/tags/latency.md>), [leadership](<https://devfeed.tech/tags/leadership.md>), [migration](<https://devfeed.tech/tags/migration.md>), [scope](<https://devfeed.tech/tags/scope.md>), [system-design](<https://devfeed.tech/tags/system-design.md>)

### AI overview

This article presents the 3P framework--Problem, Proof, and Proactive pitch--for making an engineer's promotion case legible before review. It argues that promotion reflects the scope or blast radius of decisions, supported by system evidence and an explicit pitch.

### Source excerpt

Promotion committees do not promote effort, they promote scope, and scope has to be legible before the vote rather than explained after it fails. Strip the leveling-guide language and the question is blast radius: a mid-level engineer's bad call fails one deploy unit, a senior's saturates a pool at 2 AM across teams. The 3P framework makes that visible: Problem at org scale, Proof in system metrics, and a Proactive pitch.

## How ORM N+1 Queries Create Hidden Request Latency

DevFeed: [How ORM N+1 Queries Create Hidden Request Latency](<https://devfeed.tech/articles/your-orm-issued-400-queries-and-the-p99-looked-fine-until-it-didn-t-39588.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/36-orm-n-plus-one-queries-hidden-latency/>)

Author: hello@ankit-rana.com

Published: 2026-08-02T00:00:00Z

Content type: tutorial

Language: en

Sources: [Ankit Rana | Mechanical Sympathy](<https://devfeed.tech/sources/ankit-rana-mechanical-sympathy.md>)

Topics: [Object-relational mapping](<https://devfeed.tech/topics/orm.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Monitoring](<https://devfeed.tech/topics/monitoring.md>), [lazy loading](<https://devfeed.tech/topics/lazy-loading.md>), [Database](<https://devfeed.tech/topics/database.md>), [connection pool](<https://devfeed.tech/topics/connection-pool.md>)

Tags: [connection-pool](<https://devfeed.tech/tags/connection-pool.md>), [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [hibernate](<https://devfeed.tech/tags/hibernate.md>), [latency](<https://devfeed.tech/tags/latency.md>), [lazy-loading](<https://devfeed.tech/tags/lazy-loading.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [n-plus-one](<https://devfeed.tech/tags/n-plus-one.md>), [observability](<https://devfeed.tech/tags/observability.md>), [orm](<https://devfeed.tech/tags/orm.md>), [query](<https://devfeed.tech/tags/query.md>), [request](<https://devfeed.tech/tags/request.md>)

### AI overview

This article explains how ORM lazy loading can turn a loop over orders into an N+1 query pattern. Individual queries may remain fast and avoid slow-query alerts, while the accumulated network round trips increase request latency and hold connection-pool resources. It recommends monitoring queries per request and asserting query counts in tests.

### Source excerpt

N+1 queries hide from monitoring because no individual query is slow. Four hundred queries at 0.4ms each never appear in the slow query log, never move p99 query latency, and still cost the request 300ms because the expense is the round trip rather than the execution. The metric that catches it is queries per request, and the only durable fix is asserting on that count in tests, since the code that causes it looks like a field access rather than I/O.

## What Interviewers Listen for in Behavioral Interviews

DevFeed: [What Interviewers Listen for in Behavioral Interviews](<https://devfeed.tech/articles/how-to-stop-failing-behavioral-interviews-39429.md>)

Original publisher: [Read original article](<https://www.blog4ems.com/p/stop-failing-behavioral-interviews>)

Author: Stephane Moreau

Published: 2026-07-19T11:12:27Z

Content type: tutorial

Language: en

Sources: [Blog for Engineering Managers](<https://devfeed.tech/sources/blog-for-engineering-managers.md>)

Topics: [Job](<https://devfeed.tech/topics/job.md>), [incident](<https://devfeed.tech/topics/incident.md>), [service](<https://devfeed.tech/topics/service.md>), [connection pool](<https://devfeed.tech/topics/connection-pool.md>)

Tags: [connection-pool](<https://devfeed.tech/tags/connection-pool.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [guide](<https://devfeed.tech/tags/guide.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [incident](<https://devfeed.tech/tags/incident.md>), [influence](<https://devfeed.tech/tags/influence.md>), [interviews](<https://devfeed.tech/tags/interviews.md>), [junior](<https://devfeed.tech/tags/junior.md>), [scope](<https://devfeed.tech/tags/scope.md>), [service](<https://devfeed.tech/tags/service.md>), [teams](<https://devfeed.tech/tags/teams.md>)

### AI overview

This article explains how interviewers assess behavioral answers, emphasizing the scope of ambiguity, influence across teams, trade-offs, and whether candidates actively discovered problems. It argues that these signals can distinguish mid-level engineers from Staff-level engineers before the stated outcome.

### Source excerpt

What I'm actually listening for when you answer.

## Sentry's new AI grouping model reduces duplicate issues and incorrect merges

DevFeed: [Sentry's new AI grouping model reduces duplicate issues and incorrect merges](<https://devfeed.tech/articles/better-faster-less-wrong-enhancing-issue-grouping-24096.md>)

Original publisher: [Read original article](<https://blog.sentry.io/enhancing-issue-grouping/>)

Author: Kush Dubey; Yuval Mandelboum

Published: 2026-06-12T09:00:00Z

Content type: article

Language: en

Sources: [Sentry Blog](<https://devfeed.tech/sources/sentry-blog.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [Embeddings](<https://devfeed.tech/topics/embeddings.md>), [Algorithm](<https://devfeed.tech/topics/algorithm.md>), [GPU](<https://devfeed.tech/topics/gpu.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [connection-pool](<https://devfeed.tech/tags/connection-pool.md>), [embeddings](<https://devfeed.tech/tags/embeddings.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [issue](<https://devfeed.tech/tags/issue.md>), [ml](<https://devfeed.tech/tags/ml.md>), [model](<https://devfeed.tech/tags/model.md>), [production](<https://devfeed.tech/tags/production.md>), [server](<https://devfeed.tech/tags/server.md>), [timeout](<https://devfeed.tech/tags/timeout.md>)

### AI overview

Sentry describes an upgraded AI model for grouping errors into issues. The model prevents 20% more duplicate issues and halves incorrect merges, separating errors with distinct root causes that the previous model combined.

### Source excerpt

Sentry's new AI grouping model prevents 20% more duplicate issues while cutting incorrect merges in half. Here's how we trained and deployed it.

## AI agents break connection pooling by holding the slot while they think

DevFeed: [AI agents break connection pooling by holding the slot while they think](<https://devfeed.tech/articles/ai-agents-break-connection-pooling-by-holding-the-slot-while-they-think-39573.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/21-llms-connection-pooling-ai-agents/>)

Author: hello@ankit-rana.com

Published: 2026-03-21T00:00:00Z

Content type: article

Language: en

Sources: [Ankit Rana | Mechanical Sympathy](<https://devfeed.tech/sources/ankit-rana-mechanical-sympathy.md>)

Topics: [connection pool](<https://devfeed.tech/topics/connection-pool.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Back end](<https://devfeed.tech/topics/backend.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [connection-pool](<https://devfeed.tech/tags/connection-pool.md>), [connection-pooling](<https://devfeed.tech/tags/connection-pooling.md>), [databases](<https://devfeed.tech/tags/databases.md>), [latency](<https://devfeed.tech/tags/latency.md>), [llm](<https://devfeed.tech/tags/llm.md>), [performance](<https://devfeed.tech/tags/performance.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>)

### AI overview

This article explains how AI agents can exhaust database connection pools by holding connections during LLM inference. It describes the resulting queueing and latency problems, including cases where the database remains lightly loaded, and recommends releasing the connection before calling the model.

### Source excerpt

Connection pooling assumes an implicit contract that transactions stay microscopic, roughly 50 ms of database time per request. An agent that holds a pooled connection while waiting 3 to 5 seconds for LLM inference breaks that assumption: 100 concurrent agents can occupy every slot in a 100-connection pool while the database sits at 2 percent CPU. Fetch, release the connection immediately, then call the model asynchronously.

## Parallelism with Android SQLite

DevFeed: [Parallelism with Android SQLite](<https://devfeed.tech/articles/parallelism-with-android-sqlite-25628.md>)

Original publisher: [Read original article](<https://blog.p-y.wtf/parallelism-with-android-sqlite>)

Author: Pierre-Yves Ricau

Published: 2025-02-05T05:35:36Z

Content type: tutorial

Language: en

Sources: [Py's blog](<https://devfeed.tech/sources/py-s-blog.md>)

Topics: [SQLite](<https://devfeed.tech/topics/sqlite.md>), [Android](<https://devfeed.tech/topics/android.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Coroutines](<https://devfeed.tech/topics/coroutines.md>), [IO](<https://devfeed.tech/topics/io.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [blocking](<https://devfeed.tech/tags/blocking.md>), [connection-pool](<https://devfeed.tech/tags/connection-pool.md>), [coroutines](<https://devfeed.tech/tags/coroutines.md>), [io](<https://devfeed.tech/tags/io.md>), [parallelism](<https://devfeed.tech/tags/parallelism.md>), [performance](<https://devfeed.tech/tags/performance.md>), [sqlite](<https://devfeed.tech/tags/sqlite.md>)

### AI overview

This article explains how Android SQLite's default single-connection behavior causes parallel queries on the same database to block one another. It examines how excessive query parallelism can consume coroutine dispatcher threads and delay unrelated I/O tasks, then discusses using separate dispatchers for blocking database work.

### Source excerpt

The SQLDelight documentation provides this example: val players: Flow> = playerQueries.selectAll() .asFlow() .mapToList(Dispatchers.IO) This looks reasonable, right? In the Square Point Of Sale application, we recently ...

## Postgres and Connection Pooling

DevFeed: [Postgres and Connection Pooling](<https://devfeed.tech/articles/postgres-and-connection-pooling-41170.md>)

Original publisher: [Read original article](<https://www.craigkerstiens.com/2014/05/22/Postgres-and-Connection-Pooling/>)

Author: Map

Published: 2014-05-22T20:55:56Z

Content type: tutorial

Language: en

Sources: [Craig Kerstiens](<https://devfeed.tech/sources/craig-kerstiens.md>)

Topics: [connection pool](<https://devfeed.tech/topics/connection-pool.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [Object-relational mapping](<https://devfeed.tech/topics/orm.md>), [SQLAlchemy](<https://devfeed.tech/topics/sqlalchemy.md>), [Django](<https://devfeed.tech/topics/django.md>), [Rails](<https://devfeed.tech/topics/rails.md>), [Ruby](<https://devfeed.tech/topics/ruby.md>), [SSL](<https://devfeed.tech/topics/ssl.md>)

Tags: [connection-pool](<https://devfeed.tech/tags/connection-pool.md>), [connection-pooling](<https://devfeed.tech/tags/connection-pooling.md>), [database](<https://devfeed.tech/tags/database.md>), [django](<https://devfeed.tech/tags/django.md>), [orm](<https://devfeed.tech/tags/orm.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [python](<https://devfeed.tech/tags/python.md>), [rails](<https://devfeed.tech/tags/rails.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [sqlalchemy](<https://devfeed.tech/tags/sqlalchemy.md>), [ssl](<https://devfeed.tech/tags/ssl.md>)

### AI overview

A primer on database connection pooling explains how pooled, persistent, and standalone connections reduce connection-establishment overhead, including SSL negotiation. It discusses framework support in Ruby, Python, Rails, and Django, and notes Postgres connection and memory considerations.

### Source excerpt

Connection pooling is quickly becoming one of the more frequent questions I hear. So here's a primer on it. If there's enough demand I'll follow up a bit further with some detail on specific Postgres connection poolers and setting them up. The basics For those unfamiliar, a connection pool is a group of database connections sitting around that are waiting to be handed out and used. This means when a request comes in a connection is already there whether in your framework or some other pooling process, and then given to your application for that specific request or transaction. In contrast, without any connection pooling your application will have to reach out to your database to establish a connection. While in the most basic sense you may thinking connecting to a database is quick, often theres some overhead here. An example is SSL negotiation that may have to occur which means you're looking at not 1-2 ms but often closer to 30-50. The options There's really two major options when it comes to connection pooling: Framework pooling Standalone pooler Persistent connections Framework pooling Today many modern application frameworks have at least some basic level of connection pooling. This means as your application server starts up it will create a pool of connections to use. It's worth noting that while most modern frameworks have pooling, not all do, and further it may not be enabled by default. If you're using the Sequel ORM for Ruby or SQLAlchemy for Python you're well covered here. Further Rails is in pretty good shape also, though you may want to configure the pool size. For Django it's a bit of a mixed story. For some time Django did not have pooling at all. As of Django 1.6 you now have persistent connections by default and the ability to enable a pool. Persistent connections Persistent connections don't offer all of the benefits of pooling, but can often work well enough. Persistent connections is the act of maintaining a connection to your database once it's

## The Ruby Sequel ORM on the Hibernate Connection Pool

DevFeed: [The Ruby Sequel ORM on the Hibernate Connection Pool](<https://devfeed.tech/articles/the-ruby-sequel-orm-on-the-hibernate-connection-pool-15914.md>)

Original publisher: [Read original article](<https://developer.squareup.com/blog/the-ruby-sequel-orm-on-the-hibernate-connection-pool>)

Author: Square Engineering

Published: 2013-06-28T16:03:00Z

Content type: tutorial

Language: en

Sources: [Square Corner Blog](<https://devfeed.tech/sources/square-corner-blog-medium.md>), [Square Corner Blog RSS Feed](<https://devfeed.tech/sources/square-corner-blog-rss-feed.md>)

Topics: [Object-relational mapping](<https://devfeed.tech/topics/orm.md>), [Ruby](<https://devfeed.tech/topics/ruby.md>), [Java](<https://devfeed.tech/topics/java.md>), [Databases](<https://devfeed.tech/topics/databases.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [connection-pool](<https://devfeed.tech/tags/connection-pool.md>), [database](<https://devfeed.tech/tags/database.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [hibernate](<https://devfeed.tech/tags/hibernate.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [integration](<https://devfeed.tech/tags/integration.md>), [orm](<https://devfeed.tech/tags/orm.md>), [ruby](<https://devfeed.tech/tags/ruby.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

This tutorial explains how to run Ruby's Sequel ORM on a Hibernate-managed connection pool, allowing Java and JRuby to share database connections. It describes the connection-pool proxy, JDBC adapters, and custom Sequel integration.

### Source excerpt

We will demonstrate how to unify access to your database by leveraging the same connection in Java and JRuby.

## Prepared Statements and pgbouncer

DevFeed: [Prepared Statements and pgbouncer](<https://devfeed.tech/articles/prepared-statements-and-pgbouncer-34342.md>)

Original publisher: [Read original article](<https://tapoueh.org/blog/2009/05/prepared-statements-and-pgbouncer/>)

Author: Dimitri Fontaine PostgreSQL Major Contributor; Author

Published: 2009-05-13T22:00:00Z

Content type: article

Language: en

Sources: [Dimitri Fontaine](<https://devfeed.tech/sources/dimitri-fontaine.md>)

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [backends](<https://devfeed.tech/topics/backends.md>)

Tags: [connection-pool](<https://devfeed.tech/tags/connection-pool.md>), [performance](<https://devfeed.tech/tags/performance.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [scalability](<https://devfeed.tech/tags/scalability.md>)

### AI overview

The article discusses using PgBouncer connection pooling with PostgreSQL prepared statements to improve scalability for applications serving many concurrent clients. It describes an application-side preparation check and the preprepare project, which provides a function to prepare statements from a table at connection creation time.

### Source excerpt

On the performance mailing list, a recent thread drew my attention. It devired to be about using a connection pool software and prepared statements in order to increase scalability of PostgreSQL when confronted to a lot of concurrent clients all doing simple select queries. The advantage of the pooler is to reduce the number of backends needed to serve the queries, thus reducing PostgreSQL internal bookkeeping. Of course, my choice of software here is clear: PgBouncer is an excellent top grade solution, performs real well (it won't parse queries), reliable, flexible.