TOPIC
Databases
These are the same questions found in the library, grouped here by the capability each one mainly examines.
69 questions
Questions 1–50 of 69 on this page.
A · Professional problem solving and implementation35
- Enterprise knowledge documents may change, be withdrawn, or become restricted, yet users still receive answers citing old content. How would you propagate changes from source documents through chunks, indexes, caches, and existing citations, and prove that an update or deletion took effect?
- A user updates account settings and refreshes immediately, but a read replica returns the old value. Reading from the primary adds load, while waiting for replication may time out. How would you design the experience?
- When writing code and reviewing it, what checks have become habit for avoiding performance problems such as querying a database inside a loop or holding large objects too long? How do you know they actually work?
- A cache can make reads faster and can also show users stale content. How do you decide whether a piece of data suits caching, and how do you notice when it goes wrong?
- A query filters on an indexed column and is still slow. Explain how an index lookup works and what can keep it from helping.
- When two transactions modify the same data at once, what anomalies can occur? What does each isolation level prevent, and what does it cost?
- A new field must be backfilled across hundreds of millions of rows. The first run increases lock waits and replication lag. How would you decide whether to pause, batch, throttle, or use an online migration?
- A new index speeds up queries, but write latency and storage growth worsen noticeably. How would you decide whether to keep it?
- After reads move to replicas, users sometimes cannot see a change immediately after a successful write. How would you define and handle stale reads?
- An API has been slow since yesterday, and there is no release on record. Given logs, monitoring, and database slow-query records, in what order would you investigate?
- A cache key is invalidated and logs show a database reread, yet some users still see old data. Switching to the primary helps but does not eliminate it. How would you investigate caches, replicas, and clients?
- The application can be rolled back, but a database migration removed an old field and the previous version can no longer start. How would you redesign release order and rollback?
- A user requests deletion of personal data, but some records have reached backups, analytics warehouses, and downstream systems. How would you design a verifiable deletion process?
- Backups report success, but the team has never verified restored data integrity or recovery time. How would you establish demonstrable recovery capability?
- Before drawing any architecture diagram, which few numbers would you use to decide whether a service should be split or cached? Use a service you know to explain.
- The local database has updated, but syncing the cache or sending a downstream message fails. How would you make the systems converge and handle retries, compensation, or manual recovery?
- How would you design a search system? How do indexing, retrieval, and ranking divide the work, how are Chinese segmentation and features built, and how do you judge how good the search is?
- An admin console must retain operation records that cannot be casually altered, support queries by actor and object, and handle years of growth. How would you design writes, indexes, and retention?
- API latency rises while database CPU remains low, and application logs show connection waits. How would you distinguish connection leaks, an undersized pool, and slow transactions holding connections?
- After writing an order to a database, a service must publish an event downstream; the process may crash at either step. How would you design durable publication and handle duplicates and ordering?
- In an admin console, inserts and deletes while paging by creation time cause duplicate or missing rows. How would you compare offset and cursor pagination and define the consistency expectation?
- A storage service shifts from read-heavy to sustained writes, and the team is comparing B-tree and LSM approaches. Which workload characteristics would guide the choice, and what read/write amplification costs would you examine?
- After a database field change, only some downstream jobs fail intermittently. How would you identify consumers still using the old contract and decide between rollback and a compatibility fix?
- A reconciliation shows timestamps from two data centers placing event A before B, while the message trace shows B triggered A. How would you distinguish clock skew, processing delay, and business causality, and choose trustworthy diagnostic evidence?
- A high-traffic service must move a critical table to a new model without pausing reads or writes. How would you organize the migration stages and verify a safe cutover?
- A service’s resident memory is stable, but major page faults, disk I/O, and tail latency rise together. How would you distinguish changes in the working set, mapping behavior, memory pressure, and application access patterns?
- A search service must change tokenization and ranking features without long result gaps or a major increase in write latency. How would you evolve the index?
- A subscription product includes trials, renewals, grace periods, refunds, and family sharing. How would you design entitlement checks so several services receive consistent, traceable results?
- Several teams copy de-identified data into development, staging, and performance environments with different refresh schedules. How would you design access, lifecycle, and reproducibility?
- After changing an embedding model, old and new vectors are not directly comparable, while a full rebuild takes days. How would you design migration and query cutover?
- After deployment on a multi-socket machine, threads move across NUMA nodes and memory latency varies. How would you investigate using CPU affinity, memory placement, and scheduling behavior?
- After certificate rotation, short connections work, but some clients fail a handshake when reconnecting or resuming after a long-lived connection closes. How would you distinguish certificate-chain, resumption, connection-pool, and client-cache effects?
- When a mobile device switches from Wi-Fi to cellular, some HTTP/3 requests fail while the session still appears online. How would you investigate path migration, timeouts, and middlebox behavior?
- A program writes a data file before updating its index, but after a power loss the index points to incomplete content. How would you analyze write ordering, flush semantics, and recovery?
- Two requests almost simultaneously check that a business object is absent and then both create it; the application-level check-then-write occasionally produces duplicates. How would you use transaction isolation, unique constraints, and conflict handling to preserve the invariant?
No questions in this section match your target. ·
B · Business understanding and domain modeling15
- In a system that handles money, how should accounting and billing be designed so the numbers are clear and reconcile? How do you model accounts, entries, holds, settlement, and reconciliation, and how do you trace and correct an error?
- How should amounts, currencies, rounding, and time zones be expressed in a transaction and settlement model? Which practices look fine but break at reconciliation?
- Taking concepts such as orders, contracts, and settlements, how are they mapped into the data model? Which concepts were split into several entities, which were merged, and why?
- A user asks to have personal data deleted, while finance must retain transaction records for audit. How would you define the boundary among deletion, anonymization, and traceability?
- In a behavioral event table, what exactly does one row represent? Explain how you settle its grain, and which statistics go wrong when the grain is unclear.
- A monthly close report was sent to leadership. Days later, a late refund and price correction arrive. The business wants current figures updated, while finance must explain the prior report. How would you model this?
- Orders, payments, and refunds are often stored in one table. How would you distinguish their business identities, lifecycles, and cardinalities? Compare conditions, costs, and validation for separate models and combined storage.
- An account moves from sales to customer success mid-month. Monthly metrics must show the outcome and who owned it at each point. How would you define ownership events and reporting rules?
- A fee rule changes today, but a disputed order was created under the old rule. How would you preserve rule versions and transaction facts so finance can reproduce the original calculation?
- An order has a single status field that means both fulfillment progress and payment result, and several teams read it. How would you split it into two concepts and move old data and old consumers over smoothly?
- A business rule is corrected retroactively. Reports need corrected results, while decision-makers also need the results available at the time. How would you manage both historical views?
- Support agents merge duplicate tickets and sometimes split a complex issue into several cases. When modeling service-quality data, how would you define the issue, ticket, contact, and resolution?
- Partner settlement must connect external order IDs, internal orders, payments, and refunds, but systems use different keys and update times. How would you build the mappings and reconciliation process?
- Business reports mix orders, order lines, and payment attempts, so metrics disagree across pages. How would you establish fact-table grain and validate aggregation semantics?
- The source database has deleted a customer, but a change data capture (CDC) pipeline and downstream summary views still show the old record. How would you trace the deletion event, update dependent views, and verify cleanup?
No questions in this section match your target. ·