Search the practice set
126 questions, 454 terms and 400 topics in 20 areas.
60 results for “Database Performance”
Database Index
A secondary structure that lets the engine find rows without scanning, trading write cost and storage for read speed.
Connection Pool
A fixed set of reusable database connections shared by an application's requests, and one of the most common hidden capacity ceilings.
Join Strategies
The three ways a database combines two row sets — nested loop, hash join and merge join — and the conditions under which each is correct.
Query Plan
The database's chosen strategy for executing a query, and the first thing to look at when one is slow.
Application Performance Monitoring
Instrumentation inside the application that attributes latency and errors to specific code paths, queries and dependencies.
Blue-Green Database Schema
The constraint that makes fast rollback actually work — both application versions must be able to run against one schema at the same time.
Database per Service
Each service owning its own datastore, with no other service reading or writing it directly.
Graph Database
A store whose first-class citizens are nodes and the relationships between them, making multi-hop traversal cheap.
Vector Database
A store optimised for approximate nearest-neighbour search over high-dimensional embeddings.
Airbnb's Service-Oriented Migration
Airbnb decomposed a large Rails monolith by first extracting a unified data-access layer, so that services were built on owned data rather than on shared database tables.
Bloom Filter
A compact probabilistic structure that answers "is this key definitely absent, or possibly present?" — no false negatives, tunable false positives.
Bloom Filter Cache Guard
Placing a Bloom filter in front of an expensive lookup so that keys which certainly do not exist never reach it.
Burstable Instance
An instance that provides a low baseline CPU allocation and accrues credits while idle, spendable for short periods of full performance.
Cache Invalidation
The problem of removing or refreshing cached data when the underlying source changes, and the reason caching is harder than it looks.
Caching Strategy
The chosen pattern for how a cache is populated, read and invalidated — cache-aside, read-through, write-through or write-behind.
Cardinality Estimation
The planner's prediction of how many rows each step of a query will produce — the input that determines every other choice it makes.
Change Data Capture
Publishing a stream of a database's row-level changes by reading its replication log, without modifying the application that owns it.
Concurrency
The number of operations in progress at once — distinct from parallelism, which is how many are literally executing simultaneously.
Connection Proxy
A pooling layer between applications and a managed database that multiplexes many client connections onto a small number of database connections.
Covering Index
An index that contains every column a query needs, so the query is answered from the index without reading the table at all.
DORA Metrics
Four measures of software delivery performance — deployment frequency, lead time for change, change failure rate, and time to restore service.
Denormalisation
Deliberately duplicating data across records to make reads cheap, accepting the write-time cost of keeping copies in step.
Foreign Key Constraint
A database-enforced rule that a referencing value must exist in the referenced table — referential integrity that no application bug can violate.
Google Maps and Planetary-Scale Spatial Serving
Map serving is fast because almost nothing is computed on request — the world is precomputed into a pyramid of tiles, and space is indexed onto a one-dimensional curve.
Hedged Request
Sending a duplicate of a request to a second replica after a short delay and using whichever response returns first, to cut tail latency.
Hexagonal Architecture
Putting the domain at the centre and letting everything external — UI, database, queues — attach through ports implemented by replaceable adapters.
Horizontal vs Vertical Scaling
Adding more machines versus making one machine bigger — and the fact that vertical is underrated for stateful tiers.
Indexing Strategy
Choosing the set of indexes a table carries by working backwards from its actual queries, and accepting the write cost that each one adds.
Little's Law
In a stable system, the average number of items in it equals the arrival rate times the average time each spends in it — L = λW.
Load Testing
Driving a system with realistic traffic at a target volume to verify it meets its performance targets before real users do.
A product catalogue page does 40,000 reads per second against a database that can serve 5,000. Walk me through the caching design, including what happens at 3 AM when the cache is empty.
What the interviewer is testing Whether you can design a cache including its failure modes, rather than saying "put Redis in front of it". The base design Cache
A downstream team needs to react to order changes. The order service can publish events, or they can consume CDC from its database. Which, and why?
The recommendation: published events, with CDC as the mechanism if needed The distinction that matters is what the consumer becomes coupled to . CDC consumed di
A multi-tenant SaaS product has outgrown one database. You must shard. How do you choose the partition key, and what makes this decision so expensive to get wrong?
What the interviewer is testing Whether you exhaust cheaper options first, and whether you understand that a shard key is close to irreversible. First: do not s
A serverless API works in testing and fails under load with connection errors. The database is at 5% CPU. Explain and fix.
The mechanism Serverless functions scale by creating independent execution environments , each with its own process and its own connection pool. Two hundred con
A service writes to its database and then publishes an event to Kafka. Sometimes consumers see an event for a record that does not exist, and sometimes a record exists with no event. Why, and how do you fix it?
What the interviewer is testing Recognition of the dual write problem — one of the most common defects in event driven systems and one that testing rarely catch
An estate has database passwords in environment variables across 200 services. Design the migration to a secrets manager.
Sequence it by risk, not by convenience Phase 0 — stop the bleeding. Secret scanning in CI and on the existing repositories, blocking new commits containing cre
Anomalous access to a customer database is detected. Walk me through the first day, and say what determines whether you can answer the regulator.
The first hours Declare an incident and assign command. Named commander who does not debug, operations lead, communications lead, scribe. Security incidents add
You are asked to give an internal AI agent access to the customer database, the ticketing system and outbound email so it can resolve support tickets. What is your response?
What the interviewer is testing Whether you recognise a specific and well documented security pattern, and whether you can propose a workable design instead of
Your search index and your database disagree — some products appear in search that were deleted, and some new ones never appear. How do you make this reliable?
Why it drifts Almost always a dual write : the application writes to the database and then to the search index as two independent operations. One can succeed an
A dashboard query that took 200ms now takes 40 seconds. The table has grown to 200 million rows. Walk me through diagnosis and fix, including what you would not do.
What the interviewer is testing Whether you diagnose with evidence before changing anything, and whether you know the costs of the fixes you propose. Diagnosis,
A table has 14 indexes and writes have become slow. How do you decide which to remove?
The approach 1. Get usage statistics, not opinions. Every major engine reports index scan counts — PostgreSQL's pg stat user indexes , SQL Server's sys.dm db in
Database Performance
Plans, indexes, contention and the pool in front of the database.
Application Performance Monitoring
Attributing latency to code paths, queries and dependencies.
Caching for Performance
Layer choice, hit ratio as a first-class metric, and cold-cache recovery.
Database Migration
Moving engines, versions and schemas without losing data or uptime.
Network Performance
Latency floors, bandwidth-delay product, and what no code change fixes.
Network Performance Tuning
Keep-alive, compression, payload size and round-trip elimination.
Performance & Capacity
General material on performance and capacity engineering.
Performance Budgets
Targets enforced in CI so regressions fail the build.
Performance vs Cost
Buying latency, and knowing what the last millisecond is worth.
Bottleneck Analysis
Finding the constraint, and expecting a second one behind it.
Capacity Modelling
Arithmetic before load tests, and headroom for failure as well as peak.
Change Data Capture
Turning a database's replication log into a stream, and its coupling risk.
Concurrency
Operations in flight, and the limits that are the real capacity ceiling.
Connection Pooling
The most common hidden ceiling, and the metric nobody collects.
Horizontal vs Vertical Scaling
Scale out for stateless, scale up first for stateful.
Latency
Distributions rather than averages, and the floors physics imposes.
Little's Law
L = λW, and the pool sizes it computes directly.
Load Testing
Realistic data, realistic mix, and a ramp rather than a step.