# database performance

Published articles for database performance.

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

## Troubleshooting row lock contention in Amazon Aurora PostgreSQL: Part 1 - Understanding row lock contention in PostgreSQL

DevFeed: [Troubleshooting row lock contention in Amazon Aurora PostgreSQL: Part 1 - Understanding row lock contention in PostgreSQL](<https://devfeed.tech/articles/troubleshooting-row-lock-contention-in-amazon-aurora-postgresql-part-1-understanding-row-lock-contention-in-postgresql-20843.md>)

Original publisher: [Read original article](<https://aws.amazon.com/blogs/database/troubleshooting-row-lock-contention-in-amazon-aurora-postgresql-part-1-understanding-row-lock-contention-in-postgresql/>)

Author: Sameer Kumar

Published: 2026-09-14T16:02:08Z

Content type: tutorial

Language: en

Sources: [AWS Database Blog](<https://devfeed.tech/sources/aws-database-blog.md>)

Topics: [Amazon Aurora](<https://devfeed.tech/topics/amazon-aurora.md>), [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Monitoring](<https://devfeed.tech/topics/monitoring.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [Amazon CloudWatch](<https://devfeed.tech/topics/amazon-cloudwatch.md>), [Amazon RDS](<https://devfeed.tech/topics/amazon-rds.md>), [Architecture & Design](<https://devfeed.tech/topics/architecture-design.md>), [Extension](<https://devfeed.tech/topics/extension.md>)

Tags: [advanced-300](<https://devfeed.tech/tags/advanced-300.md>), [amazon-aurora](<https://devfeed.tech/tags/amazon-aurora.md>), [amazon-cloudwatch](<https://devfeed.tech/tags/amazon-cloudwatch.md>), [amazon-rds](<https://devfeed.tech/tags/amazon-rds.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [availability](<https://devfeed.tech/tags/availability.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [extension](<https://devfeed.tech/tags/extension.md>), [locks](<https://devfeed.tech/tags/locks.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [production](<https://devfeed.tech/tags/production.md>), [rds-for-postgresql](<https://devfeed.tech/tags/rds-for-postgresql.md>), [technical-how-to](<https://devfeed.tech/tags/technical-how-to.md>), [transactions](<https://devfeed.tech/tags/transactions.md>), [troubleshooting](<https://devfeed.tech/tags/troubleshooting.md>)

### AI overview

This first part of a two-part series explains row lock contention in PostgreSQL and Amazon Aurora PostgreSQL. It covers how concurrent transactions competing for the same rows can reduce throughput and cause timeouts despite healthy CPU and I/O, then introduces PostgreSQL locking internals and monitoring techniques using system views, functions, the pgrowlocks extension, and log_lock_waits. The article notes that the same behavior and investigation approach apply to Amazon RDS for PostgreSQL.

### Source excerpt

Row lock contention can collapse database throughput during a flash sale even when CPU and I/O look healthy. In Part 1 of this series, learn how PostgreSQL row locking works and how to monitor lock contention in Amazon Aurora PostgreSQL and Amazon RDS for PostgreSQL using system views, the pgrowlocks extension, and the log_lock_waits parameter.

## JDBC batching can still issue one round trip per row unless driver statement rewriting is enabled

DevFeed: [JDBC batching can still issue one round trip per row unless driver statement rewriting is enabled](<https://devfeed.tech/articles/one-round-trip-beats-a-thousand-and-your-batch-api-probably-is-not-batching-39599.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/47-batching-one-round-trip-beats-a-thousand/>)

Author: hello@ankit-rana.com

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

Content type: tutorial

Language: en

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

Topics: [Databases](<https://devfeed.tech/topics/databases.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [client](<https://devfeed.tech/topics/client.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [batching](<https://devfeed.tech/tags/batching.md>), [bulk-load](<https://devfeed.tech/tags/bulk-load.md>), [client](<https://devfeed.tech/tags/client.md>), [cost](<https://devfeed.tech/tags/cost.md>), [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [durability](<https://devfeed.tech/tags/durability.md>), [jdbc](<https://devfeed.tech/tags/jdbc.md>), [latency](<https://devfeed.tech/tags/latency.md>), [mysql](<https://devfeed.tech/tags/mysql.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [server](<https://devfeed.tech/tags/server.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

For small database writes, network round trips and transaction overhead can dominate the actual insert work. The article explains that JDBC batching may accept rows into a client-side batch while still sending separate statements unless driver-side statement rewriting is enabled, and that autocommit adds a transaction and durability barrier per row.

### Source excerpt

For small writes the per-statement overhead dominates the actual work, so throughput is set by round trips rather than by the database. JDBC batching is the usual fix and it silently does nothing on the wire unless the driver is told to rewrite the statements, so addBatch can look correct while still issuing one round trip per row. Autocommit compounds it by turning every row into its own transaction and its own durability barrier, which is the difference between one fsync and a hundred thousand.

## Foreign keys are not overhead, and the thing you measured was a missing index

DevFeed: [Foreign keys are not overhead, and the thing you measured was a missing index](<https://devfeed.tech/articles/foreign-keys-are-not-overhead-and-the-thing-you-measured-was-a-missing-index-39597.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/45-foreign-keys-are-not-overhead/>)

Author: hello@ankit-rana.com

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

Content type: opinion

Language: en

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

Topics: [Database](<https://devfeed.tech/topics/database.md>), [integrity](<https://devfeed.tech/topics/integrity.md>)

Tags: [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [foreign-keys](<https://devfeed.tech/tags/foreign-keys.md>), [indexing](<https://devfeed.tech/tags/indexing.md>), [integrity](<https://devfeed.tech/tags/integrity.md>), [overhead](<https://devfeed.tech/tags/overhead.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [referential-integrity](<https://devfeed.tech/tags/referential-integrity.md>), [schema-design](<https://devfeed.tech/tags/schema-design.md>)

### AI overview

The article explains that the measured cost of a slow parent delete is usually caused by a missing index on the child table's foreign-key column, not by foreign-key checking itself. It argues that dropping the constraint merely moves referential-integrity enforcement into application code and can allow orphaned records.

### Source excerpt

A foreign key check is an index lookup against a primary key that is almost certainly already in cache, which is close to the cheapest thing a database does. The expensive case people measure is a parent delete with no index on the child's referencing column, which forces a full scan of the child table per deleted row, and that is a missing index rather than a cost of the constraint. Dropping the key does not remove the work, it moves the integrity guarantee into application code where nothing reports when it stops holding.

## Benchmarking vector indexes

DevFeed: [Benchmarking vector indexes](<https://devfeed.tech/articles/benchmarking-vector-indexes-14092.md>)

Original publisher: [Read original article](<https://www.percona.com/blog/benchmarking-vector-indexes/>)

Author: Evgeniy Patlan

Published: 2026-08-27T13:35:32Z

Content type: article

Language: en

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

Topics: [benchmarking](<https://devfeed.tech/topics/benchmarking.md>), [Ground truth / benchmark quality](<https://devfeed.tech/topics/ground-truth-benchmark-quality.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [ann](<https://devfeed.tech/topics/ann.md>), [datasets](<https://devfeed.tech/topics/datasets.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>)

Tags: [ai-vector](<https://devfeed.tech/tags/ai-vector.md>), [ann](<https://devfeed.tech/tags/ann.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [blog](<https://devfeed.tech/tags/blog.md>), [blog-post](<https://devfeed.tech/tags/blog-post.md>), [data](<https://devfeed.tech/tags/data.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [database-trends](<https://devfeed.tech/tags/database-trends.md>), [databases](<https://devfeed.tech/tags/databases.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [embeddings](<https://devfeed.tech/tags/embeddings.md>), [index](<https://devfeed.tech/tags/index.md>), [measurements](<https://devfeed.tech/tags/measurements.md>), [model](<https://devfeed.tech/tags/model.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [percona](<https://devfeed.tech/tags/percona.md>), [points](<https://devfeed.tech/tags/points.md>), [report](<https://devfeed.tech/tags/report.md>), [run](<https://devfeed.tech/tags/run.md>), [search](<https://devfeed.tech/tags/search.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [vector-search](<https://devfeed.tech/tags/vector-search.md>), [vectorsearch](<https://devfeed.tech/tags/vectorsearch.md>)

### AI overview

This article explains how Percona's vector-bench measures vector indexes by building database engines from pinned versions, running them in identical containers with the same data and hardware, and comparing consistent measurements. It describes embeddings, exact search, approximate nearest neighbour search, and ground truth as the brute-force reference needed to evaluate index accuracy.

### Source excerpt

Nearly every database has vector search now, and every one of them has a blog post with a big number in it. Almost none of those numbers can be checked, because the thing that makes them meaningful is usually missing. We built a vector-bench to stop guessing. You name the engines you want, build them ... Continued The post Benchmarking vector indexes appeared first on Percona.

## 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.

## Covering Indexes and Index-Only Scans in PostgreSQL

DevFeed: [Covering Indexes and Index-Only Scans in PostgreSQL](<https://devfeed.tech/articles/covering-indexes-the-cheap-10x-that-most-schemas-leave-on-the-table-39591.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/39-covering-indexes-index-only-scans/>)

Author: hello@ankit-rana.com

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

Content type: tutorial

Language: en

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

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Query (disambiguation)](<https://devfeed.tech/topics/query.md>), [data](<https://devfeed.tech/topics/data.md>)

Tags: [b-tree](<https://devfeed.tech/tags/b-tree.md>), [cache](<https://devfeed.tech/tags/cache.md>), [covering](<https://devfeed.tech/tags/covering.md>), [covering-index](<https://devfeed.tech/tags/covering-index.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [explain](<https://devfeed.tech/tags/explain.md>), [heap](<https://devfeed.tech/tags/heap.md>), [indexes](<https://devfeed.tech/tags/indexes.md>), [indexing](<https://devfeed.tech/tags/indexing.md>), [innodb](<https://devfeed.tech/tags/innodb.md>), [pages](<https://devfeed.tech/tags/pages.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [query](<https://devfeed.tech/tags/query.md>), [storage](<https://devfeed.tech/tags/storage.md>), [vacuum](<https://devfeed.tech/tags/vacuum.md>)

### AI overview

This tutorial explains why a normal index scan may still be slow: after finding matching entries, the database follows a pointer into the table for each row. Covering indexes store the selected columns in the index and can avoid those heap reads. In PostgreSQL, index-only scans also depend on the visibility map marking pages all-visible, while SELECT * prevents the technique from being fully effective.

### Source excerpt

A normal index scan finds matching rows and then follows a pointer into the table for every one of them, which is a random read per row. A covering index stores the columns the query selects, so the engine answers entirely from the index and skips those reads. In PostgreSQL this only works when the visibility map marks the pages all-visible, so an unvacuumed table will report Heap Fetches in EXPLAIN and give back most of the gain. SELECT star defeats the technique completely.

## Why your index is not being used, and why the planner is usually right

DevFeed: [Why your index is not being used, and why the planner is usually right](<https://devfeed.tech/articles/why-your-index-is-not-being-used-and-why-the-planner-is-usually-right-39590.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/38-why-your-index-is-not-being-used/>)

Author: hello@ankit-rana.com

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

Content type: tutorial

Language: en

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

Topics: [Query (disambiguation)](<https://devfeed.tech/topics/query.md>), [MySQL](<https://devfeed.tech/topics/mysql.md>), [bug](<https://devfeed.tech/topics/bug.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [cardinality](<https://devfeed.tech/tags/cardinality.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [explain](<https://devfeed.tech/tags/explain.md>), [function](<https://devfeed.tech/tags/function.md>), [indexes](<https://devfeed.tech/tags/indexes.md>), [indexing](<https://devfeed.tech/tags/indexing.md>), [mysql](<https://devfeed.tech/tags/mysql.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [predicate](<https://devfeed.tech/tags/predicate.md>), [query](<https://devfeed.tech/tags/query.md>), [query-planner](<https://devfeed.tech/tags/query-planner.md>)

### AI overview

This tutorial explains why database indexes may not be used even when they exist. It focuses on inaccurate cardinality estimates caused by stale statistics, predicates that prevent index matching, implicit casts, and cases where sequential scans are the cheaper choice.

### Source excerpt

An unused index is almost never a planner bug. It is usually a predicate the planner cannot match to the index, such as a function or an implicit cast applied to the column, or a cardinality estimate that is wrong because statistics are stale. When the estimate is right and the planner still refuses, it is often correct: past a few percent of the table, random access through an index costs more than reading the table sequentially. The diagnostic that matters is the gap between estimated and actual rows in EXPLAIN ANALYZE.

## 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.

## Pagination at Scale: Why OFFSET and SKIP Will Eventually Break Your API

DevFeed: [Pagination at Scale: Why OFFSET and SKIP Will Eventually Break Your API](<https://devfeed.tech/articles/pagination-at-scale-why-offset-and-skip-will-eventually-break-your-api-39566.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/14-pagination-offset-vs-cursor/>)

Author: hello@ankit-rana.com

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

Content type: tutorial

Language: en

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

Topics: [API](<https://devfeed.tech/topics/api.md>), [Database](<https://devfeed.tech/topics/database.md>), [MongoDB](<https://devfeed.tech/topics/mongodb.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [api-design](<https://devfeed.tech/tags/api-design.md>), [b-tree](<https://devfeed.tech/tags/b-tree.md>), [cursor](<https://devfeed.tech/tags/cursor.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [latency](<https://devfeed.tech/tags/latency.md>), [mongodb](<https://devfeed.tech/tags/mongodb.md>), [pagination](<https://devfeed.tech/tags/pagination.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [scale](<https://devfeed.tech/tags/scale.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

This article explains why OFFSET and SKIP pagination become slower and more memory-intensive as page depth increases. It presents cursor-based, or keyset, pagination as an alternative that uses an indexed range seek and reads a fixed number of rows, keeping fetch cost largely constant with list depth. The trade-off is that cursor pagination does not provide reliable absolute page numbers.

### Source excerpt

OFFSET does not seek. The engine fetches offset plus limit rows, sorts them, and discards the first N, so cost grows linearly with page depth. Cursor pagination passes the last seen key instead of a page number, letting the B+ tree seek in logarithmic time and read a fixed number of rows, which keeps latency flat at any depth. The price is losing absolute page numbers.

## How UUIDv4 Primary Keys Affect Database Insert Performance

DevFeed: [How UUIDv4 Primary Keys Affect Database Insert Performance](<https://devfeed.tech/articles/why-uuid-primary-keys-quietly-destroy-database-performance-39564.md>)

Original publisher: [Read original article](<https://ankit-rana.com/logs/12-uuids-primary-keys-performance/>)

Author: hello@ankit-rana.com

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

Content type: article

Language: en

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

Topics: [Database](<https://devfeed.tech/topics/database.md>), [MySQL](<https://devfeed.tech/topics/mysql.md>), [ordering](<https://devfeed.tech/topics/ordering.md>)

Tags: [b-tree](<https://devfeed.tech/tags/b-tree.md>), [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [fragmentation](<https://devfeed.tech/tags/fragmentation.md>), [innodb](<https://devfeed.tech/tags/innodb.md>), [latency](<https://devfeed.tech/tags/latency.md>), [mysql](<https://devfeed.tech/tags/mysql.md>), [performance](<https://devfeed.tech/tags/performance.md>), [system-design](<https://devfeed.tech/tags/system-design.md>), [uuid](<https://devfeed.tech/tags/uuid.md>)

### AI overview

This article explains how random UUIDv4 primary keys can reduce insert performance in clustered indexes. Random inserts land in the middle of B+ tree pages, causing page splits, fragmentation, additional writes, and buffer-pool churn. It recommends UUIDv7 or ULID, or an auto-increment clustered key with UUIDs in a unique secondary index.

### Source excerpt

The problem with UUIDv4 primary keys is not uniqueness, it is that random keys fight the storage engine's physical layout. In a clustered index the primary key is the table, so random inserts land mid-page, trigger page splits, leave pages half-full, and can inflate a 50 GB dataset to roughly 100 GB while wasting buffer pool on empty space. Use UUIDv7 or ULID, or keep an auto-increment clustered key with the UUID in a unique secondary index.

## How io\_uring improves database performance

DevFeed: [How io\_uring improves database performance](<https://devfeed.tech/articles/how-io-uring-improves-database-performance-39641.md>)

Original publisher: [Read original article](<https://www.gauravsarma.com/posts/2025-12-11_how-iouring-improves-database-performance>)

Published: 2025-12-11T00:00:00Z

Content type: tutorial

Language: en

Sources: [Gaurav Sarma's Blog](<https://devfeed.tech/sources/gaurav-sarma-s-blog.md>)

Topics: [io\_uring](<https://devfeed.tech/topics/io-uring.md>), [Databases](<https://devfeed.tech/topics/databases.md>), [Linux Kernel](<https://devfeed.tech/topics/linux-kernel.md>), [NVMe](<https://devfeed.tech/topics/nvme.md>)

Tags: [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [io](<https://devfeed.tech/tags/io.md>), [io-uring](<https://devfeed.tech/tags/io-uring.md>), [nvme](<https://devfeed.tech/tags/nvme.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

This article explains how io_uring improves database performance through shared submission and completion queues, batching, fewer system calls, zero-copy operation, and features such as SQPoll and registered buffers. It also discusses DMA and the relevance of fast NVMe storage.

### Source excerpt

. [How io_uring Improves Database Performance](how-iouring-improves-database-performance-cover...

## Locality, and Temporal-Spatial Hypothesis

DevFeed: [Locality, and Temporal-Spatial Hypothesis](<https://devfeed.tech/articles/locality-and-temporal-spatial-hypothesis-12578.md>)

Original publisher: [Read original article](<http://brooker.co.za/blog/2025/10/05/locality.html>)

Author: Marc Brooker

Published: 2025-10-05T00:00:00Z

Content type: article

Language: en

Sources: [Marc Brooker's Blog](<https://devfeed.tech/sources/marc-brooker-s-blog.md>), [Marc Brooker's Blog](<https://devfeed.tech/sources/marc-brooker-s-blog-2.md>)

Topics: [Databases](<https://devfeed.tech/topics/databases.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [systems](<https://devfeed.tech/topics/systems.md>), [IO](<https://devfeed.tech/topics/io.md>), [Streaming](<https://devfeed.tech/topics/streaming.md>), [Time Series](<https://devfeed.tech/topics/time-series.md>), [observability](<https://devfeed.tech/topics/observability.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [io](<https://devfeed.tech/tags/io.md>), [linux](<https://devfeed.tech/tags/linux.md>), [metrics](<https://devfeed.tech/tags/metrics.md>), [observability](<https://devfeed.tech/tags/observability.md>), [performance](<https://devfeed.tech/tags/performance.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [streaming](<https://devfeed.tech/tags/streaming.md>), [systems](<https://devfeed.tech/tags/systems.md>), [time-series](<https://devfeed.tech/tags/time-series.md>)

### AI overview

The article examines locality in database and computer-system performance, focusing on how temporal and spatial locality influence caching, read-ahead, and data layout. It develops the temporal-spatial locality hypothesis and compares its relevance for streaming, time-series, metrics, observability, and hash-based database systems.

### Source excerpt

Locality, and Temporal-Spatial Hypothesis Good fences make good neighbors? Last week at PGConf NYC, I had the pleasure of hearing Andres Freund talking about the great work he's been doing to bring async IO to Postgres 18. One particular result caught my eye: a large difference in performance between forward and reverse scans, seemingly driven by read ahead1. The short version is that IO layers (like Linux's) optimize performance by proactively pre-fetching data ahead of the current read point in a file, so it's already cached when needed. Notably, most of these systems don't do this backwards. This leads to a big difference in performance between forward scans (where the pages are already in the cache when they're needed) and backward scans (where the database needs to block on IO to fetch the next page). This lead me to thinking more about a particular hypothesis behind many database designs: a temporal-spatial locality hypothesis2. Before we get there, let's talk about locality more generally, because it might be the single most important idea in database performance (and computer systems performance generally). Temporal locality is the idea that data accessed recently is likely to be accessed again soon. This idea is what's behind CPU caches, database buffer pools, and most caches you'll come across in computer systems. Spatial locality is the idea that when we access data, we're likely to access nearby data soon. Almost all database systems take advantage of these forms of locality, and would lost significant performance without taking advantage of them. Stacks of books could be written about these ideas. Stacks of books have been written about these ideas. We could talk about cache-oblivious algorithms, or non-polluting read and write instructions, or have an argument about linked lists. Instead, I want to zoom in to a particular idea in databases: temporal-spatial hypothesis. The hypothesis I mean has a definition something like this: Temporal-spatial localit

## SEON Achieves 80% Faster Database Performance for Anti-Fraud Platform with ClickHouse on AWS

DevFeed: [SEON Achieves 80% Faster Database Performance for Anti-Fraud Platform with ClickHouse on AWS](<https://devfeed.tech/articles/seon-achieves-80-faster-database-performance-for-anti-fraud-platform-with-clickhouse-on-aws-5562.md>)

Original publisher: [Read original article](<https://clickhouse.com/blog/seon-clickhouse-aws>)

Author: AWS

Published: 2025-07-23T09:16:59Z

Content type: article

Language: en

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

Topics: [clickhouse](<https://devfeed.tech/topics/clickhouse.md>), [Amazon Web Services (AWS)](<https://devfeed.tech/topics/amazon-web-services-aws.md>), [Database](<https://devfeed.tech/topics/database.md>), [data analytics](<https://devfeed.tech/topics/data-analytics.md>), [real-time](<https://devfeed.tech/topics/real-time.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [Security, Privacy and Abuse Prevention](<https://devfeed.tech/topics/security-privacy-and-abuse-prevention.md>), [API](<https://devfeed.tech/topics/api.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>)

Tags: [analytics](<https://devfeed.tech/tags/analytics.md>), [api](<https://devfeed.tech/tags/api.md>), [aws](<https://devfeed.tech/tags/aws.md>), [clickhouse](<https://devfeed.tech/tags/clickhouse.md>), [data](<https://devfeed.tech/tags/data.md>), [data-analytics](<https://devfeed.tech/tags/data-analytics.md>), [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [fraud](<https://devfeed.tech/tags/fraud.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [performance](<https://devfeed.tech/tags/performance.md>), [real-time](<https://devfeed.tech/tags/real-time.md>), [scalability](<https://devfeed.tech/tags/scalability.md>), [storage](<https://devfeed.tech/tags/storage.md>)

### AI overview

SEON worked with ClickHouse and AWS to improve the performance and scalability of its anti-fraud and anti-money-laundering platform. The solution reduced processing time by more than 80 percent while supporting near-real-time transaction analysis and large, customized rule sets.

### Source excerpt

Learn how anti-fraud platform SEON worked with ClickHouse and used AWS to improve near real-time data analytics by 80% and reduce data storage costs by 30%

## Property Finder Optimizes Database Performance, Reduces Costs by 50% with ClickHouse on AWS

DevFeed: [Property Finder Optimizes Database Performance, Reduces Costs by 50% with ClickHouse on AWS](<https://devfeed.tech/articles/property-finder-optimizes-database-performance-reduces-costs-by-50-with-clickhouse-on-aws-5294.md>)

Original publisher: [Read original article](<https://clickhouse.com/blog/how-property-finder-migrated-to-clickhouse>)

Author: AWS

Published: 2025-07-21T00:00:00Z

Content type: article

Language: en

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

Topics: [clickhouse](<https://devfeed.tech/topics/clickhouse.md>), [Amazon Web Services (AWS)](<https://devfeed.tech/topics/amazon-web-services-aws.md>), [Database](<https://devfeed.tech/topics/database.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [Website](<https://devfeed.tech/topics/website.md>)

Tags: [amazon-web-services](<https://devfeed.tech/tags/amazon-web-services.md>), [aws](<https://devfeed.tech/tags/aws.md>), [clickhouse](<https://devfeed.tech/tags/clickhouse.md>), [data-engineering](<https://devfeed.tech/tags/data-engineering.md>), [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

Property Finder migrated to ClickHouse running on Amazon Web Services to improve database and analytics performance across regions. The article reports a 50% reduction in operating costs, a fivefold improvement in website performance, and a 96% improvement in database query speed.

### Source excerpt

"ClickHouse and AWS are the most trusted collaborators we have. We've benefited massively from our joint product roadmap" Khaled Thabit - Director of Data Engineering, Property Finder

## Heroku Postgres 17 with the New Upgrade Process: Faster Performance, Easier Upgrade

DevFeed: [Heroku Postgres 17 with the New Upgrade Process: Faster Performance, Easier Upgrade](<https://devfeed.tech/articles/heroku-postgres-17-with-the-new-upgrade-process-faster-performance-easier-upgrade-26439.md>)

Original publisher: [Read original article](<https://www.heroku.com/blog/heroku-postgres-17-new-upgrade-process-faster-performance-easier-upgrade/>)

Author: Jonathan Brown

Published: 2025-05-29T15:32:49Z

Content type: release

Language: en

Sources: [Heroku](<https://devfeed.tech/sources/heroku.md>)

Topics: [Heroku](<https://devfeed.tech/topics/heroku.md>), [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [upgrade](<https://devfeed.tech/topics/upgrade.md>), [Database](<https://devfeed.tech/topics/database.md>), [JSON](<https://devfeed.tech/topics/json.md>), [Monitoring](<https://devfeed.tech/topics/monitoring.md>), [Latency](<https://devfeed.tech/topics/latency.md>)

Tags: [availability](<https://devfeed.tech/tags/availability.md>), [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [heroku](<https://devfeed.tech/tags/heroku.md>), [heroku-postgres](<https://devfeed.tech/tags/heroku-postgres.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [news](<https://devfeed.tech/tags/news.md>), [performance](<https://devfeed.tech/tags/performance.md>), [performance-optimization](<https://devfeed.tech/tags/performance-optimization.md>), [platform-updates](<https://devfeed.tech/tags/platform-updates.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [sql-json](<https://devfeed.tech/tags/sql-json.md>), [upgrade](<https://devfeed.tech/tags/upgrade.md>)

### AI overview

Heroku announces the general availability of Heroku Postgres 17 and makes a new version-upgrade method the default. The release includes query and write performance improvements, enhanced JSON support, lower vacuum memory usage, and expanded observability features.

### Source excerpt

We're excited to announce the general availability of Heroku Postgres version 17, packed with new features and enhancements to your database performance. And that's not all - we're also introducing a game-changing feature that streamlines your upgrade experience. This new method of version upgrade is now the default, so you can try it to upgrade [...] The post Heroku Postgres 17 with the New Upgrade Process: Faster Performance, Easier Upgrade appeared first on Heroku.

## Introducing Warehouses: Compute-compute separation in ClickHouse Cloud

DevFeed: [Introducing Warehouses: Compute-compute separation in ClickHouse Cloud](<https://devfeed.tech/articles/introducing-warehouses-compute-compute-separation-in-clickhouse-cloud-5346.md>)

Original publisher: [Read original article](<https://clickhouse.com/blog/introducing-warehouses-compute-compute-separation-in-clickhouse-cloud>)

Author: Dmitry Pavlov

Published: 2025-01-27T00:00:00Z

Content type: article

Language: en

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

Topics: [clickhouse](<https://devfeed.tech/topics/clickhouse.md>), [Cloud](<https://devfeed.tech/topics/cloud.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [clickhouse](<https://devfeed.tech/tags/clickhouse.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [operations](<https://devfeed.tech/tags/operations.md>), [performance](<https://devfeed.tech/tags/performance.md>), [resource](<https://devfeed.tech/tags/resource.md>)

### AI overview

This blog introduces compute-compute separation in ClickHouse Cloud. The approach assigns isolated compute resources to different users, workloads, or database operations so that resource-intensive queries are less likely to affect the performance and stability of other workloads. It is presented as a way to improve workload isolation, resource management, and cost efficiency, including by separating reads from writes and protecting critical operations such as INSERTs and UPDATEs.

### Source excerpt

This blog describes how compute-compute is helping ClickHouse Cloud customers achieve better tenant isolation and optimize their overall resource consumption and costs.

## Choosing the right Postgres indexes

DevFeed: [Choosing the right Postgres indexes](<https://devfeed.tech/articles/choosing-the-right-postgres-indexes-11716.md>)

Original publisher: [Read original article](<https://incident.io/blog/choosing-the-right-postgres-indexes>)

Author: Milly Leadley

Published: 2024-10-25T16:45:00Z

Content type: tutorial

Language: en

Sources: [The incident.io Blog](<https://devfeed.tech/sources/the-incident-io-blog.md>)

Topics: [Database](<https://devfeed.tech/topics/database.md>), [Sorting](<https://devfeed.tech/topics/sorting.md>)

Tags: [blog](<https://devfeed.tech/tags/blog.md>), [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [incident](<https://devfeed.tech/tags/incident.md>), [incident-channel](<https://devfeed.tech/tags/incident-channel.md>), [incident-management](<https://devfeed.tech/tags/incident-management.md>), [incident-response](<https://devfeed.tech/tags/incident-response.md>), [learn](<https://devfeed.tech/tags/learn.md>), [outage](<https://devfeed.tech/tags/outage.md>), [performance](<https://devfeed.tech/tags/performance.md>), [post-mortem](<https://devfeed.tech/tags/post-mortem.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [slack-incident](<https://devfeed.tech/tags/slack-incident.md>), [sorting](<https://devfeed.tech/tags/sorting.md>), [strategy](<https://devfeed.tech/tags/strategy.md>)

### AI overview

A practical guide to choosing Postgres indexes to improve query performance. It explains sequential and index scans, the tradeoffs of disk space and slower writes, suitable indexing scenarios, b-tree indexes, unique indexes, and column ordering in multi-column indexes.

### Source excerpt

Indexes can dramatically boost your database performance, but knowing when to use them isn't always obvious. This blog covers what indexes are, when to use them, how to choose the right type, and tips for spotting missing ones. Whether you're optimizing queries, enforcing uniqueness, or improving sorting, you'll learn how to fine-tune your indexing strategy without overcomplicating it.

## Battling database performance

DevFeed: [Battling database performance](<https://devfeed.tech/articles/battling-database-performance-11747.md>)

Original publisher: [Read original article](<https://incident.io/blog/database-performance>)

Author: Rory Bain

Published: 2023-04-20T00:00:00Z

Content type: article

Language: en

Sources: [The incident.io Blog](<https://devfeed.tech/sources/the-incident-io-blog.md>)

Topics: [Database](<https://devfeed.tech/topics/database.md>), [observability](<https://devfeed.tech/topics/observability.md>), [incident](<https://devfeed.tech/topics/incident.md>), [Traces](<https://devfeed.tech/topics/traces.md>), [Grafana](<https://devfeed.tech/topics/grafana.md>), [Go Language](<https://devfeed.tech/topics/go-language.md>), [API](<https://devfeed.tech/topics/api.md>)

Tags: [app](<https://devfeed.tech/tags/app.md>), [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [errors](<https://devfeed.tech/tags/errors.md>), [go](<https://devfeed.tech/tags/go.md>), [grafana](<https://devfeed.tech/tags/grafana.md>), [http](<https://devfeed.tech/tags/http.md>), [incident](<https://devfeed.tech/tags/incident.md>), [incident-channel](<https://devfeed.tech/tags/incident-channel.md>), [incident-management](<https://devfeed.tech/tags/incident-management.md>), [incident-response](<https://devfeed.tech/tags/incident-response.md>), [logs](<https://devfeed.tech/tags/logs.md>), [observability](<https://devfeed.tech/tags/observability.md>), [on-call](<https://devfeed.tech/tags/on-call.md>), [outage](<https://devfeed.tech/tags/outage.md>), [performance](<https://devfeed.tech/tags/performance.md>), [post-mortem](<https://devfeed.tech/tags/post-mortem.md>), [slack-incident](<https://devfeed.tech/tags/slack-incident.md>), [traces](<https://devfeed.tech/tags/traces.md>)

### AI overview

The article describes intermittent database-related application timeouts that occurred over two weeks. It explains how incident investigation, Grafana dashboards, traces, and connection-pool instrumentation revealed requests waiting nearly 20 seconds for database connections, and discusses performance and observability changes made to address the issue.

### Source excerpt

Earlier this year, we experienced intermittent timeouts in our application -- here's how we tried to address the underlying issue over the next two weeks.

## Measuring Realtime Database performance with Firebase Performance Monitoring

DevFeed: [Measuring Realtime Database performance with Firebase Performance Monitoring](<https://devfeed.tech/articles/measuring-realtime-database-performance-with-firebase-performance-monitoring-16380.md>)

Original publisher: [Read original article](<https://firebase.blog/posts/2021/03/rtdb-performance-monitoring>)

Author: Sam Stern

Published: 2021-03-12T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [Firebase](<https://devfeed.tech/topics/firebase.md>), [Realtime Database](<https://devfeed.tech/topics/realtime-database.md>), [Monitoring](<https://devfeed.tech/topics/monitoring.md>), [real user monitoring](<https://devfeed.tech/topics/real-user-monitoring.md>), [Latency](<https://devfeed.tech/topics/latency.md>), [SDK](<https://devfeed.tech/topics/sdk.md>), [WebSocket](<https://devfeed.tech/topics/websocket.md>), [React](<https://devfeed.tech/topics/react.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [firebase](<https://devfeed.tech/tags/firebase.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [latency](<https://devfeed.tech/tags/latency.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [performance](<https://devfeed.tech/tags/performance.md>), [performance-monitoring](<https://devfeed.tech/tags/performance-monitoring.md>), [react](<https://devfeed.tech/tags/react.md>), [real-user-monitoring](<https://devfeed.tech/tags/real-user-monitoring.md>), [realtime](<https://devfeed.tech/tags/realtime.md>), [realtime-database](<https://devfeed.tech/tags/realtime-database.md>), [tutorials](<https://devfeed.tech/tags/tutorials.md>), [web](<https://devfeed.tech/tags/web.md>), [websocket](<https://devfeed.tech/tags/websocket.md>)

### AI overview

This tutorial explains how to measure Realtime Database performance with Firebase Performance Monitoring. It uses custom traces to measure database operations over the long-running WebSocket connection and examines how latency varies by user geography.

### Source excerpt

News, tutorials, and updates from the Firebase team.

## Introducing HaloDB, a fast, embedded key-value storage engine written in Java

DevFeed: [Introducing HaloDB, a fast, embedded key-value storage engine written in Java](<https://devfeed.tech/articles/introducing-halodb-a-fast-embedded-key-value-storage-engine-written-in-java-20489.md>)

Original publisher: [Read original article](<https://yahooeng.tumblr.com/post/178262468576>)

Author: amberwilsonla-blog

Published: 2018-09-19T23:48:42Z

Content type: release

Language: en

Sources: [Yahoo](<https://devfeed.tech/sources/yahoo.md>)

Topics: [Databases](<https://devfeed.tech/topics/databases.md>), [Java](<https://devfeed.tech/topics/java.md>), [benchmarking](<https://devfeed.tech/topics/benchmarking.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [Software](<https://devfeed.tech/topics/software.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [data](<https://devfeed.tech/tags/data.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [embedded](<https://devfeed.tech/tags/embedded.md>), [go](<https://devfeed.tech/tags/go.md>), [java](<https://devfeed.tech/tags/java.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [performance](<https://devfeed.tech/tags/performance.md>), [yahoo-engineering](<https://devfeed.tech/tags/yahoo-engineering.md>)

### AI overview

Yahoo developers introduces HaloDB, an embedded key-value storage engine written in Java. Built for an IO-bound workload with high read and write throughput, HaloDB uses append-only log files and an in-memory index. The article reports a 50% improvement in write capacity while maintaining submillisecond read latency at the 99th percentile, and announces the project's availability under the Apache license.

### Source excerpt

yahoodevelopers: By Arjun Mannaly, Senior Software Engineer At Oath, multiple ad platforms use a high throughput, low latency distributed key-value database that runs in data centers all over the world. The database stores billions of records and handles millions of read and write requests per second at millisecond latencies. The data we have in this database must be persistent, and the working set is larger than what we can fit in memory. Therefore, a key component of the database performance is a fast storage engine. Our current solution had served us well, but it was primarily designed for a read-heavy workload and its write throughput started to be a bottleneck as write traffic increased. There were other additional concerns as well; it took hours to repair a corrupted DB, or iterate over and delete records. The storage engine also didn't expose enough operational metrics. The primary concern though was the write performance, which based on our projections, would have been a major obstacle for scaling the database. With these concerns in mind, we began searching for an alternative solution. We searched for a key-value storage engine capable of dealing with IO-bound workloads, with submillisecond read latencies under high read and write throughput. After concluding our research and benchmarking alternatives, we didn't find a solution that worked for our workload, thus we were inspired to build HaloDB. Now, we're glad to announce that it's also open source and available to use under the terms of the Apache license. HaloDB has given our production boxes a 50% improvement in write capacity while consistently maintaining a submillisecond read latency at the 99th percentile. Architecture HaloDB primarily consists of append-only log files on disk and an index of keys in memory. All writes are sequential writes which go to an append-only log file and the file is rolled-over once it reaches a configurable size. Older versions of records are removed to make space by a bac

## Profiling your Realtime Database Performance

DevFeed: [Profiling your Realtime Database Performance](<https://devfeed.tech/articles/profiling-your-realtime-database-performance-16182.md>)

Original publisher: [Read original article](<https://firebase.blog/posts/2017/03/profiling-your-realtime-database>)

Author: Tyler Rockwood

Published: 2017-03-14T00:00:00Z

Content type: tutorial

Language: en

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

Topics: [Firebase](<https://devfeed.tech/topics/firebase.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [Database](<https://devfeed.tech/topics/database.md>)

Tags: [app-quality](<https://devfeed.tech/tags/app-quality.md>), [cli](<https://devfeed.tech/tags/cli.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [firebase](<https://devfeed.tech/tags/firebase.md>), [firebase-cli](<https://devfeed.tech/tags/firebase-cli.md>), [launch](<https://devfeed.tech/tags/launch.md>), [profiling](<https://devfeed.tech/tags/profiling.md>), [realtime-database](<https://devfeed.tech/tags/realtime-database.md>), [speed](<https://devfeed.tech/tags/speed.md>)

### AI overview

Firebase introduces a profiler built into the Firebase CLI for monitoring Realtime Database performance. The database:profile command reports path-level speed, bandwidth, and unindexed-query data, with an optional raw output mode for more detailed operation information.

### Source excerpt

News, tutorials, and updates from the Firebase team.

## IdentityCache: Improving Performance one Cached Model at a Time

DevFeed: [IdentityCache: Improving Performance one Cached Model at a Time](<https://devfeed.tech/articles/identitycache-improving-performance-one-cached-model-at-a-time-1437.md>)

Original publisher: [Read original article](<https://shopify.engineering/identitycache-improving-performance-one-cached-model-at-a-time>)

Author: Camilo Lopez

Published: 2013-04-04T13:24:00Z

Content type: article

Language: en

Sources: [Shopify Engineering](<https://devfeed.tech/sources/shopify-engineering.md>), [Shopify Engineering - Shopify Engineering](<https://devfeed.tech/sources/shopify-engineering-shopify-engineering.md>)

Topics: [Caching](<https://devfeed.tech/topics/caching.md>), [Shopify](<https://devfeed.tech/topics/shopify.md>), [Database](<https://devfeed.tech/topics/database.md>), [Library](<https://devfeed.tech/topics/library.md>), [web applications](<https://devfeed.tech/topics/web-applications.md>)

Tags: [activerecord](<https://devfeed.tech/tags/activerecord.md>), [caching](<https://devfeed.tech/tags/caching.md>), [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [library](<https://devfeed.tech/tags/library.md>), [performance](<https://devfeed.tech/tags/performance.md>), [shopify](<https://devfeed.tech/tags/shopify.md>)

### AI overview

Shopify open-sources IdentityCache, an internal library that caches ActiveRecord models in Memcached. The article explains how moving database reads to the cache improved performance and resilience as traffic and write-heavy sales events increased.

### Source excerpt

A month ago Shopify was at BigRubyConf where we mentioned an internal library we use for caching ActiveRecord models called IdentityCache. We're pleased to say that the library has been extracted out of the Shopify code base and has been open sourced! At Shopify, our core application has been database performance bound for much of our platform's history. That means that the most straightforward way of making Shopify more performant and resilient is to move work out of the database layer.

## Understanding Postgres Performance

DevFeed: [Understanding Postgres Performance](<https://devfeed.tech/articles/understanding-postgres-performance-41118.md>)

Original publisher: [Read original article](<https://www.craigkerstiens.com/2012/10/01/Understanding-Postgres-Performance/>)

Author: Map

Published: 2012-10-01T20:55:56Z

Content type: tutorial

Language: en

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

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [Caching](<https://devfeed.tech/topics/caching.md>), [Database](<https://devfeed.tech/topics/database.md>), [Heroku Postgres](<https://devfeed.tech/topics/heroku-postgres.md>), [Amazon EC2](<https://devfeed.tech/topics/amazon-ec2.md>)

Tags: [cache](<https://devfeed.tech/tags/cache.md>), [database](<https://devfeed.tech/tags/database.md>), [database-performance](<https://devfeed.tech/tags/database-performance.md>), [ec2](<https://devfeed.tech/tags/ec2.md>), [heroku](<https://devfeed.tech/tags/heroku.md>), [heroku-postgres](<https://devfeed.tech/tags/heroku-postgres.md>), [index](<https://devfeed.tech/tags/index.md>), [indexes](<https://devfeed.tech/tags/indexes.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [postgres-performance](<https://devfeed.tech/tags/postgres-performance.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>)

### AI overview

A practical guide to assessing PostgreSQL performance for application developers. It explains how to check cache hit rates, when to increase available database cache, and how index usage and table size can indicate opportunities for improvement.

### Source excerpt

Update theres a more recent post that expands further on where to start optimizing specific queries, and of course if you want to dig into optimizing your infrastructure High Performance PostgreSQL is still a great read For many application developers their database is a black box. Data goes in, comes back out and in between there developers hope its a pretty short time span. Without becoming a DBA there's a few pieces of data that most application developers can easily grok which will help them understand if their database is performing adequately. This post will provide some quick tips that allow you to determine whether your database performance is slowing down your app, and if so what you can do about it. Understanding your Cache and its Hit Rate The typical rule for most applications is that only a fraction of its data is regularly accessed. As with many other things data can tend to follow the 80/20 rule with 20% of your data accounting for 80% of the reads and often times its higher than this. Postgres itself actually tracks access patterns of your data and will on its own keep frequently accessed data in cache. Generally you want your database to have a cache hit rate of about 99%. You can find your cache hit rate with: SELECT sum(heap_blks_read) as heap_read, sum(heap_blks_hit) as heap_hit, sum(heap_blks_hit) / (sum(heap_blks_hit) + sum(heap_blks_read)) as ratio FROM pg_statio_user_tables; We can see in this dataclip that the cache rate for Heroku Postgres is 99.99%. If you find yourself with a ratio significantly lower than 99% then you likely want to consider increasing the cache available to your database, you can do this on Heroku Postgres by performing a fast database changeover or on something like EC2 by performing a dump/restore to a larger instance size. Understanding Index Usage The other primary piece for improving performance is indexes. Several frameworks will add indexes on your primary keys, though if you're searching on other fields or joini