Object Version and ETag
Distinguish an object’s version identity from its ETag and checksum, fetch the intended version, and avoid ordering opaque version IDs.
-
-
Delivery Revision and Restatement
Separate retries from corrected deliveries, reject stale revisions, and replace a period only from a validated complete replacement.
-
Delivery Manifest
Bind a delivered file set to its period, revision, counts, and checksums, and distinguish matching bytes from complete source data.
-
Chunked Checksum
Compare aligned key ranges with counts and canonical hashes, include destination-only keys, and repair differences without overwriting newer data.
-
Delete Tombstone
Retain the deletion evidence needed to reject old updates, and distinguish versioned sink markers from Kafka null-value tombstone records.
-
Keyset Pagination
Resume an ordered query after the last key pair, handle timestamp ties, and distinguish pagination correctness from late-commit capture.
-
Snapshot and Stream Handoff
Connect an initial database snapshot to a retained change stream without gaps, using a supported boundary rather than independently sampled times.
-
Logical Replication Slot
Understand PostgreSQL logical slots, retained WAL and consumer progress, and why a slot does not prove that an analytical destination is current.
-
Read Replica
Move suitable reads to a replica while accounting for replay lag, query conflicts, source load, and the limits of failover and CDC support.
-
Schema Evolution and Compatibility
Distinguish backward and forward compatibility, test supported readers and writers, and keep structural changes separate from changes in meaning.
-
Event Deduplication
Recognize repeated deliveries with stable event IDs, detect conflicting payloads, and keep delivery deduplication separate from business uniqueness.
-
Event Envelope
Separate shared event metadata from business properties, define identifier and timestamp scopes, and distinguish supplied fields from trusted evidence.
-
Tracking Plan
Define event triggers, properties, units, owners, and consumers in a tracking plan, then test whether deployed instrumentation follows it.
-
Batch Load Ledger
Bind each batch ID to immutable input, commit its ledger entry with the load, and understand why different IDs can still duplicate the same records.
-
Data Quarantine
Retain rejected records with reasons and identity, decide when partial output is acceptable, and provide a traceable route for corrected data.
-
Data Backfill
Recompute a bounded historical range with explicit inputs and logic, account for downstream dependencies, and coordinate with ordinary loads.
-
Upsert and Merge
Use keys and source versions to insert or update rows, reject ambiguous conflicts, and distinguish upsert from delete handling and history.
-
Partition Overwrite
Replace a declared partition with its complete desired contents, handle empty partitions, and avoid using changed rows as a replacement snapshot.
-
Data Staging Area
Isolate a load candidate before publication, retain the evidence needed for replay, and distinguish a staging area from a temporary table.
-
ETL and ELT
Compare ETL and ELT by the chosen load boundary, locate each transformation, and understand what retained input makes possible after a logic change.
-
Checkpoint and Replay
Restore consistent operator state and input position, understand replay, and separate checkpoint recovery from exactly-once external effects.
-
Late Data and Lookback
Use a lookback to revise recent results, distinguish late arrivals from corrections, and plan a route for data beyond the automatic horizon.
-
Event-Time Watermark
Understand an event-time watermark, how it differs from an extraction cursor, and why delay, idle inputs, and bad clocks change window results.
-
Event Time and Processing Time
Distinguish when an event happened from when an operator handled it, choose the clock for a metric, and check timestamp quality before grouping.
-
Micro-Batch Processing
See how repeated bounded increments can power streaming, why trigger frequency is not freshness, and what safe retries must preserve.
-
Valid Time and System Time
Distinguish business validity from recorded system versions, preserve both when needed, and avoid mistaking a load timestamp for complete history.
-
Point-in-Time Join
Join each fact to the intended historical value, validate per-row match counts, and check availability time before using the result as a feature.
-
Slowly Changing Dimensions
Choose overwrite or version history per attribute, define interval boundaries, and understand what a type 2 dimension cannot recover.
-
Fact and Dimension Tables
Separate measured events from descriptive context, declare the grain, and choose aggregation rules before joining facts and dimensions.
-
Database Normalization
Use dependencies to reduce update, insertion, and deletion anomalies, while keeping historical facts at the grain where they belong.
-
Incremental Extraction Watermark
Track incremental extraction progress, handle timestamp ties and late commits, and advance the checkpoint only after the destination commits.
-
Reverse ETL
Move modeled data into operational tools with stable keys, field ownership, deletion rules, and retry handling that respects downstream effects.
-
Data Mart
Design a data mart for a defined business subject, with explicit row grain, metric meaning, freshness, and a safe way to publish replacements.
-
Medallion Architecture
Understand bronze, silver, and gold as refinement roles, choose useful boundaries, and separate layer names from quality and transaction guarantees.
-
Data Contract
Define a data contract with meaning, keys, units, ownership, quality rules, and a change process that consumers can actually depend on.
-
Edge Case
Learn what an edge case is, why boundary rows break rules that work on typical data, and how to decide the behavior instead of discovering it.
-
Minimal Reproducible Example
Build a small runnable example that preserves a failure, state expected and actual results, and replace real data without removing the bug.
-
Error Message and Traceback
Learn how to read an error message and traceback, trace a failing value through calls, and keep useful details when searching for an explanation.
-
LSM Tree
Follow a write from memtable to sorted files, and see how compaction, tombstones, and filters trade write, read, and space costs.
-
Database Deadlock
Distinguish a blocking wait from a deadlock cycle, understand victim rollback, and retry the whole transaction with consistent lock ordering.
-
Transaction Isolation
Compare PostgreSQL statement and transaction snapshots, understand write skew, and retry the complete decision when serialization fails.
-
MVCC and Snapshot
See how versions and visibility rules give readers a stable view, why old snapshots delay cleanup, and what a consistent view cannot guarantee.
-
Write-Ahead Logging
Understand what must become durable before a commit is acknowledged, how checkpoints advance recovery, and why WAL is not a backup or audit trail.
-
Query Execution Plan
Read scans, joins, row estimates, loops, and buffer work in a query execution plan without treating estimated cost as elapsed milliseconds.
-
Composite and Covering Index
Distinguish a composite index’s key order from query coverage, and see why a PostgreSQL index-only scan can still visit the heap.
-
B-tree Index
Understand how a B-tree index narrows a lookup or range, why table visits may remain, and how read savings compete with write and storage costs.
-
Database Session
Learn what a database session holds, which objects and settings die with it, and why connection pooling makes session state unreliable.
-
Database View
Learn how a view stores a query instead of rows, which data a read can see, how a materialized view differs, and what it does not guarantee.
-
Recursive CTE
Learn how a recursive CTE builds rows from an anchor query, what stops it, and where generated calendars and hierarchy walks are worth it.
-
CTE Materialization
Learn what it means for a CTE to be materialized or inlined, which engines decide what, and how execution strategy differs from name scope.