Data Engineering

Trace a data record from an operational source through ingestion, storage, transformation, and analytical consumption.

Distinguish OLTP workloads from OLAP workloads using latency, concurrency, and query-pattern requirements.

Choose between batch and streaming processing for a given freshness and complexity requirement.

Navigate Linux files, directories, permissions, and environment variables from the command line.

Compose shell pipelines that filter, transform, and redirect text data.

Diagnose a basic CPU, memory, disk, process, or network issue using Linux commands.

Perform a Git workflow using branches, commits, merges, and conflict resolution.

Trace an API request through DNS resolution, TCP/TLS connection establishment, and HTTP exchange.

Design a relational table with appropriate primary-key, foreign-key, uniqueness, and validation constraints.

Normalize a relational schema to third normal form.

Predict SQL query results involving NULL and three-valued logic.

Write correct inner, outer, semi, and anti joins for specified data requirements.

Use SQL window functions to calculate rankings, running totals, and period comparisons.

Structure a multi-step SQL transformation using common table expressions.

Identify transaction isolation anomalies from concurrent database operations.

Interpret a SQL execution plan to locate costly scans, joins, and sorts.

Declare the grain of a fact table from an analytical business process.

Classify measures as additive, semi-additive, or non-additive.

Design a star schema with conformed dimensions for a stated reporting requirement.

Implement a Type 2 slowly changing dimension using effective dates and current-row indicators.

Map raw, staging, core, and presentation layers to their responsibilities in an ELT architecture.

Explain how Snowflake separates storage, compute, and cloud services.

Relate Snowflake micro-partitions, pruning, and clustering to query performance.

Select Snowflake virtual-warehouse settings that balance concurrency, latency, and cost.

Create a reproducible Python project using isolated dependencies and a package-based directory structure.

Represent validated data records using type hints and data classes.

Process a file larger than memory using iterators and generators.

Implement a transformation that parses, validates, and quarantines malformed records.

Handle transient failures with bounded retries and explicit exception propagation.

Select threading, multiprocessing, or asynchronous I/O for a specified Python workload.

Write a pytest unit test that isolates an external dependency with a test double.

Profile a Python data task to identify its principal CPU or memory bottleneck.

Select row-oriented or column-oriented storage for a specified access pattern.

Explain how Parquet row groups, column statistics, and dictionary encoding support analytical reads.

Select a compression codec by balancing compression ratio, CPU cost, and splittability.

Design file partitions that support pruning without creating excessive small files.

Configure Amazon S3 versioning and lifecycle rules for a stated retention requirement.

Distinguish replication, partitioning, and sharding in a distributed data system.

Analyze the consistency and availability trade-off of a data service during a network partition.

Explain how data locality and network shuffles affect distributed-processing performance.

Translate a Spark job into jobs, stages, tasks, and partition-level work.

Predict when lazy Spark transformations will execute in response to an action.

Interpret a Spark physical plan to identify scans, exchanges, joins, and aggregations.

Use repartitioning and coalescing to control parallelism and output-file counts.

Select a broadcast or sort-merge join from table-size and partitioning information.

Mitigate a skewed Spark join using salting or adaptive execution techniques.

Decide whether to cache, persist, or checkpoint an intermediate Spark dataset.

Use Spark UI metrics to diagnose a CPU, memory, shuffle, or straggler bottleneck.

Choose full-refresh or incremental ingestion for a source based on volume, mutability, and available metadata.

Explain how log-based change data capture represents inserts, updates, and deletes.

Construct an Airflow DAG with explicit dependencies, scheduling, retries, and failure handling.

Make a batch load idempotent by defining stable keys and repeat-safe writes.

Plan a backfill that preserves production correctness while reprocessing historical partitions.

Define compatibility rules for evolving source and target schemas.

Design data-quality checks for schema, completeness, uniqueness, validity, and reconciliation.

Trace a failed output back to its upstream datasets using lineage metadata.

Construct a least-privilege IAM policy for a data-processing workload.

Organize an S3 data lake into governed zones with partition and lifecycle conventions.

Register S3 datasets in AWS Glue Data Catalog and query them with Amazon Athena.

Select among AWS Lambda, AWS Glue, Amazon EMR, and container services for a data workload.

Choose Amazon Redshift distribution and sort strategies for a specified query pattern.

Select an AWS ingestion approach using AWS DMS, managed transfer services, or custom connectors.

Choose between Amazon MWAA and AWS Step Functions for orchestrating a data workflow.

Secure an AWS data path using KMS encryption, secrets management, and private network connectivity.

Explain how an append-only event log is divided into ordered partitions.

Choose an event key that preserves required ordering while distributing producer load.

Relate consumer groups, offsets, and rebalancing to parallel event consumption.

Distinguish at-most-once, at-least-once, and effectively-once processing guarantees.

Use event time, watermarks, and allowed lateness to reason about delayed events.

Select tumbling, hopping, or session windows for a streaming aggregation.

Define backward- or forward-compatible event-schema evolution rules.

Choose between Amazon Kinesis and Amazon MSK for a stated streaming workload.

Design CI checks for formatting, unit tests, integration tests, and deployment validation in a data repository.

Represent an AWS data component with Terraform while keeping state and secrets out of source control.

Define data-pipeline service-level indicators for freshness, completeness, correctness, and availability.

Design a monitoring dashboard that connects infrastructure metrics to data-pipeline health.

Create an actionable alert with a threshold, evaluation window, owner, and runbook link.

Triage a failed production pipeline using logs, metrics, lineage, and recent deployment history.

Write a blameless incident postmortem with timeline, impact, root cause, and corrective actions.

Classify sensitive data and assign appropriate access, masking, retention, and audit controls.

Convert stakeholder needs into data-volume, freshness, correctness, availability, and retention requirements.

Estimate daily storage growth, peak throughput, and processing capacity from workload assumptions.

Choose a warehouse, data lake, or lakehouse architecture for a stated use case.

Produce an AWS data-platform design that identifies ingestion, storage, processing, serving, and orchestration components.

Perform a failure-mode analysis for the critical paths in a data-platform design.

Evaluate a proposed architecture across scalability, reliability, security, operability, and cost.

Present and defend architectural trade-offs using explicit requirements and rejected alternatives.

Solve a timed SQL interview problem involving joins, aggregation, and window functions.

Debug a faulty Python data-transformation task under interview time constraints.

Diagnose a Spark performance scenario from an execution plan and runtime metrics.

Structure a data-system-design interview from requirements discovery through trade-off discussion.

Convert data-engineering accomplishments into quantified résumé bullet points.

Construct STAR narratives for ownership, production incidents, technical disagreement, and delivery challenges.

Evaluate a mid-level data-engineering job description to identify evidence gaps and a targeted preparation plan.