🔄 AWS ETL Patterns Interview

Comprehensive interview preparation for ETL/ELT patterns, transformation strategies, and data pipeline best practices on AWS.

Module: AWS Data Engineering • Topic 59 of 65 • Premium Content

ETL/ELT Patterns Overview

Architecture Diagram

┌─────────────────────────────────────────────────────────────────────┐
│                    ETL/ELT Patterns Overview                        │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  ETL (Extract, Transform, Load)                                    │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐                     │
│  │ Extract  │───▶│ Transform│───▶│ Load     │                     │
│  │ (Source) │    │ (Engine) │    │ (Target) │                     │
│  └──────────┘    └──────────┘    └──────────┘                     │
│                                                                     │
│  ELT (Extract, Load, Transform)                                    │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐                     │
│  │ Extract  │───▶│ Load     │───▶│ Transform│                     │
│  │ (Source) │    │ (Staging)│    │ (Target) │                     │
│  └──────────┘    └──────────┘    └──────────┘                     │
│                                                                     │
│  AWS Services                                                      │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │ ETL: Glue, EMR, Lambda                                    │   │
│  │ ELT: Redshift, Athena, Spectrum                          │   │
│  │ Orchestration: Step Functions, MWAA                       │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Q1: When should you choose ETL vs ELT?

Answer:

Decision Framework:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              ETL vs ELT Decision Framework                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Choose ETL When:                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Data volume is small (<100GB)                        │   │
│  │ • Complex transformations needed                      │   │
│  │ • Target system has limited compute                   │   │
│  │ • Need to reduce storage costs                        │   │
│  │ • Data quality requires early validation              │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Choose ELT When:                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Data volume is large (>1TB)                          │   │
│  │ • Simple transformations (filter, aggregate)           │   │
│  │ • Target system has strong compute (Redshift)          │   │
│  │ • Need raw data preservation                          │   │
│  │ • Multiple consuming applications                      │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Comparison Table                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Aspect        │ ETL                │ ELT                │   │
│  │ Storage       │ Minimal            │ Raw + Processed    │   │
│  │ Compute       │ Processing engine  │ Target warehouse   │   │
│  │ Flexibility   │ Pre-defined        │ Ad-hoc queries    │   │
│  │ Cost          │ Processing cost    │ Storage + Query   │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q2: How do you design a scalable ETL pipeline?

Answer:

Scalable ETL Architecture:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Scalable ETL Pipeline Architecture                 │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Ingestion (Scale: Parallel)                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Kinesis Data Firehose (auto-scaling)                 │   │
│  │ • S3 event notifications (trigger-based)               │   │
│  │ • DMS (parallel change data capture)                   │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Processing (Scale: Distributed)                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Glue (serverless, auto-scaling workers)              │   │
│  │ • EMR (Spark, auto-scaling clusters)                   │   │
│  │ • Lambda (parallel execution)                          │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Storage (Scale: Unlimited)                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • S3 (unlimited storage, partitioned access)           │   │
│  │ • Redshift Spectrum (query S3 directly)                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Orchestration (Scale: Distributed)                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Step Functions (serverless orchestration)            │   │
│  │ • MWAA (managed Airflow)                               │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q3: How do you handle data quality in ETL pipelines?

Answer:

Data Quality Framework:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Data Quality in ETL Pipelines                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Quality Gates                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Stage 1: Schema Validation                             │   │
│  │ • Column existence                                     │   │
│  │ • Data types                                           │   │
│  │ • Required fields                                      │   │
│  │                                                          │   │
│  │ Stage 2: Data Validation                               │   │
│  │ • Null checks                                          │   │
│  │ • Range validation                                     │   │
│  │ • Format validation                                    │   │
│  │                                                          │   │
│  │ Stage 3: Business Rules                                │   │
│  │ • Referential integrity                                │   │
│  │ • Cross-column validation                              │   │
│  │ • Aggregation checks                                   │   │
│  │                                                          │   │
│  │ Stage 4: Completeness                                  │   │
│  │ • Record counts                                        │   │
│  │ • Freshness checks                                     │   │
│  │ • Coverage metrics                                     │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Quality Check Implementation:

class DataQualityEngine:
    def __init__(self):
        self.checks = []
    
    def add_check(self, name, check_func, severity='ERROR'):
        self.checks.append({
            'name': name,
            'func': check_func,
            'severity': severity
        })
    
    def validate(self, df):
        results = []
        
        for check in self.checks:
            try:
                passed = check['func'](df)
                results.append({
                    'name': check['name'],
                    'passed': passed,
                    'severity': check['severity']
                })
            except Exception as e:
                results.append({
                    'name': check['name'],
                    'passed': False,
                    'error': str(e),
                    'severity': check['severity']
                })
        
        return results

# Usage
engine = DataQualityEngine()

engine.add_check(
    'no_nulls',
    lambda df: df.filter(col('id').isNull()).count() == 0
)

engine.add_check(
    'valid_amounts',
    lambda df: df.filter(col('amount') < 0).count() == 0
)

engine.add_check(
    'referential_integrity',
    lambda df: df.join(
        spark.read.table('customers'),
        'customer_id',
        'left_anti'
    ).count() == 0
)

Q4: How do you optimize ETL job performance?

Answer:

Performance Optimization:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              ETL Performance Optimization                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Data Partitioning                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Partition by query patterns (date, region)           │   │
│  │ • Optimal size: 128MB - 1GB per file                  │   │
│  │ • Avoid too many small files                           │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  File Format Optimization                                      │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Parquet: Columnar, compressed, fast reads           │   │
│  │ • ORC: Similar to Parquet, good for Hive              │   │
│  │ • Snappy compression: Balanced speed/ratio            │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Caching                                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Cache frequently accessed lookup tables              │   │
│  │ • Use broadcast joins for small tables                 │   │
│  │ • Persist intermediate results                         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Parallelization                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Partition data for parallel processing               │   │
│  │ • Use multiple workers                                 │   │
│  │ • Implement map-side joins                             │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q5: How do you implement incremental ETL?

Answer:

Incremental Processing Patterns:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Incremental ETL Patterns                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Timestamp-Based Incremental                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ WHERE last_modified > :last_run_timestamp              │   │
│  │                                                          │   │
│  │ Pros: Simple to implement                              │   │
│  │ Cons: Missed updates if timestamp not reliable         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Change Data Capture (CDC)                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • DMS CDC                                              │   │
│  │ • Debezium                                             │   │
│  │ • Database-native (Oracle, PostgreSQL)                 │   │
│  │                                                          │   │
│  │ Pros: Captures all changes (insert, update, delete)   │   │
│  │ Cons: More complex setup                               │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Glue Job Bookmarks                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Automatically tracks processed data                  │   │
│  │ • Enables incremental processing                       │   │
│  │ • No custom watermark logic needed                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Delta Lake / Iceberg                                          │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • ACID transactions                                    │   │
│  │ • Time travel for reprocessing                         │   │
│  │ • Schema evolution                                     │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Glue Bookmark Implementation:

# Enable job bookmarking
datasource0 = glueContext.create_dynamic_frame.from_catalog(
    database="mydb",
    table_name="mytable",
    transformation_ctx="datasource0"  # Bookmark context
)

# Process only new data
apply_mapping = ApplyMapping.apply(
    frame=datasource0,
    transformation_ctx="apply_mapping"
)

# Write to destination
sink = glueContext.write_dynamic_frame.from_catalog(
    frame=apply_mapping,
    database="outputdb",
    table_name="outputtable",
    transformation_ctx="sink0"
)

Q6: How do you handle schema evolution in ETL?

Answer:

Schema Evolution Strategies:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Schema Evolution Strategies                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Forward Compatibility                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ New schema has additional columns                      │   │
│  │ Old code ignores new columns                           │   │
│  │ Use default values for new columns                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Backward Compatibility                                        │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ New schema removes columns                             │   │
│  │ Old code still expects removed columns                 │   │
│  │ Provide default values or NULL                         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Full Compatibility                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Both directions work                                   │   │
│  │ Use schema registry (Glue Schema Registry)             │   │
│  │ Version schemas                                        │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Spark Schema Evolution:

# Read with schema evolution
df = spark.read \
    .option("mergeSchema", "true") \
    .parquet("s3://bucket/data/")

# Write with schema evolution
df.write \
    .mode("append") \
    .option("mergeSchema", "true") \
    .parquet("s3://bucket/output/")

Q7: How do you implement error handling in ETL?

Answer:

Error Handling Patterns:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              ETL Error Handling Patterns                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Retry Pattern                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Exponential backoff                                  │   │
│  │ • Max retry attempts                                   │   │
│  │ • Jitter to avoid thundering herd                      │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Dead Letter Queue                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Failed records → DLQ                                 │   │
│  │ • Manual review/retry                                  │   │
│  │ • Don't block pipeline for bad records                 │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Circuit Breaker                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Stop calling failing service                         │   │
│  │ • Prevent cascade failures                             │   │
│  │ • Periodic retry to check recovery                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Idempotency                                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Safe to retry                                        │   │
│  │ • Use deterministic output paths                       │   │
│  │ • Track processed records                              │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q8: How do you orchestrate complex ETL workflows?

Answer:

Orchestration Patterns:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              ETL Orchestration Architecture                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Step Functions                                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Visual workflow designer                             │   │
│  │ • Built-in error handling                              │   │
│  │ • Serverless scaling                                   │   │
│  │ • Pay per execution                                    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  MWAA (Managed Airflow)                                        │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Complex DAG support                                  │   │
│  │ • Rich ecosystem (operators, hooks)                    │   │
│  │ • Mature scheduling                                    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Orchestration Decision Tree                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Simple linear workflow → Step Functions                 │   │
│  │ Complex DAG with dependencies → MWAA/Airflow           │   │
│  │ Event-driven → EventBridge + Lambda                    │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Step Functions Example:

{
  "StartAt": "ExtractData",
  "States": {
    "ExtractData": {
      "Type": "Task",
      "Resource": "arn:aws:states:::glue:startJobRun.sync",
      "Parameters": {"JobName": "extract"},
      "Next": "ValidateData",
      "Catch": [
        {
          "ErrorEquals": ["States.ALL"],
          "Next": "HandleError",
          "ResultPath": "$.error"
        }
      ]
    },
    "ValidateData": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:validate",
      "Next": "TransformData"
    },
    "TransformData": {
      "Type": "Task",
      "Resource": "arn:aws:states:::glue:startJobRun.sync",
      "Parameters": {"JobName": "transform"},
      "Next": "LoadData"
    },
    "LoadData": {
      "Type": "Task",
      "Resource": "arn:aws:states:::glue:startJobRun.sync",
      "Parameters": {"JobName": "load"},
      "End": true
    },
    "HandleError": {
      "Type": "Task",
      "Resource": "arn:aws:sns:publish",
      "Parameters": {
        "TopicArn": "arn:aws:sns:alerts",
        "Message.$": "$.error"
      },
      "End": true
    }
  }
}

Q9: How do you test ETL pipelines?

Answer:

ETL Testing Framework:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              ETL Testing Framework                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Unit Tests                                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Test individual transformations                      │   │
│  │ • Mock data sources                                    │   │
│  │ • Validate output schema                               │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Integration Tests                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Test end-to-end pipeline                             │   │
│  │ • Use sample data                                      │   │
│  │ • Validate data quality                                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Performance Tests                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Test with production data volumes                    │   │
│  │ • Measure execution time                               │   │
│  │ • Identify bottlenecks                                 │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Regression Tests                                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Compare output with expected results                 │   │
│  │ • Catch breaking changes                               │   │
│  │ • Automate in CI/CD                                    │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q10: How do you monitor ETL pipelines?

Answer:

ETL Monitoring Architecture:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              ETL Monitoring Architecture                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Metrics Collection                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Job duration                                         │   │
│  │ • Records processed                                    │   │
│  │ • Data quality scores                                  │   │
│  │ • Error rates                                          │   │
│  │ • Cost per job                                         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Logging                                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • CloudWatch Logs (structured JSON)                    │   │
│  │ • S3 logs (detailed execution logs)                    │   │
│  │ • CloudTrail (API call logging)                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Alerting                                                      │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Job failure alerts                                   │   │
│  │ • SLA breach alerts                                    │   │
│  │ • Anomaly detection                                    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Dashboard                                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Real-time job status                                 │   │
│  │ • Historical trends                                    │   │
│  │ • Cost tracking                                        │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q11: How do you implement real-time ETL?

Answer:

Real-Time ETL Architecture:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Real-Time ETL Architecture                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Stream Processing                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Kinesis Data Streams + Lambda                        │   │
│  │ • MSK + Kafka Streams                                  │   │
│  │ • Kinesis Analytics (Flink)                            │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Micro-Batch Processing                                        │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Kinesis Data Firehose (buffering)                    │   │
│  │ • Spark Structured Streaming                           │   │
│  │ • Glue Streaming ETL                                   │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Latency Requirements                                          │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ < 1 second: Kinesis + Lambda                           │   │
│  │ < 1 minute: Kinesis Analytics                          │   │
│  │ < 5 minutes: Firehose                                  │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q12: How do you implement data lake ETL?

Answer:

Data Lake ETL Architecture:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Data Lake ETL Architecture                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Zone Architecture                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Landing → Raw → Processed → Curated                    │   │
│  │                                                          │   │
│  │ Landing: Temporary staging                             │   │
│  │ Raw: Immutable, append-only                            │   │
│  │ Processed: Cleaned, validated                          │   │
│  │ Curated: Business-ready datasets                       │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  ETL Patterns                                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Full load: Periodic complete refresh                 │   │
│  │ • Incremental: Only new/changed data                   │   │
│  │ • CDC: Real-time change capture                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  File Organization                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ s3://data-lake/                                        │   │
│  │   ├── source_a/                                        │   │
│  │   │   ├── year=2024/                                   │   │
│  │   │   │   ├── month=01/                                │   │
│  │   │   │   │   └── data.parquet                        │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q13: How do you implement data warehouse ETL?

Answer:

Data Warehouse ETL:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Data Warehouse ETL Architecture                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ETL Pattern (Transform before Load)                           │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Source → Glue/EMR → Transform → Redshift               │   │
│  │                                                          │   │
│  │ Pros: Clean data in warehouse, reduced compute         │   │
│  │ Cons: Transformation overhead, limited flexibility     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  ELT Pattern (Load then Transform)                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Source → S3 (Raw) → COPY to Redshift → SQL Transform   │   │
│  │                                                          │   │
│  │ Pros: Raw data preserved, ad-hoc transformations       │   │
│  │ Cons: Higher storage, more compute in warehouse        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Staging Tables                                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ staging_*: Temporary tables for transformations        │   │
│  │ dim_*: Dimension tables (slowly changing)              │   │
│  │ fact_*: Fact tables (append/merge)                     │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q14: How do you implement ETL for unstructured data?

Answer:

Unstructured Data ETL:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Unstructured Data ETL                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Data Types & Processing                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Images: Rekognition → Metadata → S3                    │   │
│  │ Documents: Textract → Text/Tables → S3/Athena          │   │
│  │ Audio: Transcribe → Text → Comprehend                  │   │
│  │ Video: Rekognition → Labels → S3                       │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Extraction Pipeline                                           │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ S3 → Lambda → AI Service → Metadata Store → S3         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Metadata Management                                           │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • DynamoDB for metadata storage                        │   │
│  │ • Glue Data Catalog for table metadata                 │   │
│  │ • Custom metadata schema                               │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q15: How do you implement ETL for IoT data?

Answer:

IoT ETL Architecture:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              IoT Data ETL Architecture                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Ingestion                                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ IoT Core → Rules Engine → Kinesis/S3                   │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Processing                                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Real-time: Lambda, Kinesis Analytics                 │   │
│  │ • Batch: Glue, EMR                                     │   │
│  │ • Time-series: Timestream                              │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Storage                                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Hot: Timestream (real-time queries)                  │   │
│  │ • Warm: S3 + Athena (recent data)                      │   │
│  │ • Cold: S3 Glacier (archival)                          │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Partitioning Strategy                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Partition by: device_type/year/month/day/hour          │   │
│  │ File size: 128MB - 1GB                                │   │
│  │ Format: Parquet with Snappy compression               │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q16: How do you implement data masking in ETL?

Answer:

Data Masking Patterns:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Data Masking in ETL                                │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Masking Types                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Static: Consistent masking (same input = same output)  │   │
│  │ Dynamic: Context-dependent masking                     │   │
│  │ Tokenization: Replace with tokens                      │   │
│  │ Encryption: Reversible masking                         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Implementation                                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Glue: Custom transform functions                     │   │
│  │ • Spark: UDFs for masking logic                        │   │
│  │ • Redshift: Dynamic data masking                       │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Common Patterns                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Email: j***@***.com                                    │   │
│  │ SSN: ***-**-1234                                       │   │
│  │ Credit Card: ****-****-****-1234                       │   │
│  │ Name: J*** D**                                         │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q17: How do you implement ETL for machine learning?

Answer:

ML Feature Engineering ETL:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              ML Feature Engineering ETL                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Feature Pipeline                                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Raw Data → Feature Engineering → Feature Store          │   │
│  │                        │                                 │   │
│  │                        ├── Online Store (DynamoDB)      │   │
│  │                        └── Offline Store (S3)           │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Feature Types                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Batch features: Pre-computed (daily/hourly)          │   │
│  │ • Real-time features: Computed at inference time       │   │
│  │ • Windowed features: Aggregations over time windows    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  SageMaker Feature Store                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Centralized feature repository                       │   │
│  │ • Online/offline stores                                │   │
│  │ • Feature versioning                                   │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q18: How do you implement ETL governance?

Answer:

ETL Governance Framework:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              ETL Governance Framework                           │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Documentation                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Data dictionary                                      │   │
│  │ • Transformation documentation                         │   │
│  │ • Lineage tracking                                     │   │
│  │ • Runbook for operations                               │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Standards                                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Naming conventions                                   │   │
│  │ • Code review requirements                             │   │
│  │ • Testing requirements                                 │   │
│  │ • Deployment procedures                                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Monitoring                                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • SLA monitoring                                       │   │
│  │ • Quality metrics                                      │   │
│  │ • Cost tracking                                        │   │
│  │ • Performance baselines                                │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q19: How do you implement ETL cost optimization?

Answer:

ETL Cost Optimization:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              ETL Cost Optimization Strategies                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Glue Optimization                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Right-size DPUs (start with 10, scale)               │   │
│  │ • Use bookmarking for incremental processing           │   │
│  │ • Use Python Shell for simple jobs (0.0625 DPU)        │   │
│  │ • Optimize partitions (128MB-1GB files)               │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  EMR Optimization                                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Use Spot instances for task nodes                    │   │
│  │ • Auto-scaling based on workload                       │   │
│  │ • Right-size instance types                            │   │
│  │ • Use EMR Serverless for variable workloads            │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Lambda Optimization                                           │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Right-size memory (CPU scales with memory)           │   │
│  │ • Batch operations to reduce invocations               │   │
│  │ • Use provisioned concurrency for steady workloads     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Cost Comparison                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Glue: $0.44/DPU-hour                                  │   │
│  │ EMR (m5.xlarge): $0.192/hr On-Demand                  │   │
│  │ EMR (Spot): $0.058/hr (70% savings)                   │   │
│  │ Lambda: $0.0000166667/GB-second                        │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q20: How do you implement ETL for multiple data sources?

Answer:

Multi-Source ETL:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Multi-Source ETL Architecture                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Source Types                                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Databases: RDS, DynamoDB, Redshift                   │   │
│  │ • Files: S3, FTP, HTTP                                 │   │
│  │ • Streams: Kinesis, MSK                                │   │
│  │ • APIs: REST, GraphQL                                  │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Orchestration Pattern                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Parallel extraction → Merge → Transform → Load          │   │
│  │                                                          │   │
│  │ Step Functions: Parallel state for independent sources │   │
│  │ MWAA: Fan-out/fan-in pattern                          │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Data Reconciliation                                           │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Record count validation                              │   │
│  │ • Checksum verification                                │   │
│  │ • Deduplication                                        │   │
│  │ • Conflict resolution                                  │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q21: How do you implement ETL for historical data migration?

Answer:

Historical Migration Pattern:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Historical Data Migration                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Migration Strategies                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Big Bang: Migrate all at once (downtime)               │   │
│  │ Trickle: Migrate incrementally (parallel run)          │   │
│  │ Phased: Migrate by module/table                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  AWS Migration Services                                        │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • DMS: Database migration                              │   │
│  │ • SCT: Schema conversion                               │   │
│  │ • DataSync: File system migration                      │   │
│  │ • Snowball: Large data transfer                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Validation                                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Record count comparison                              │   │
│  │ • Data sampling validation                             │   │
│  │ • Business rule validation                             │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q22: How do you implement ETL for data lakehouse?

Answer:

Data Lakehouse ETL:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Data Lakehouse ETL Architecture                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Delta Lake / Iceberg                                          │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • ACID transactions on data lake                       │   │
│  │ • Time travel for versioning                           │   │
│  │ • Schema enforcement and evolution                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  ETL Patterns                                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Full load to Delta Lake                              │   │
│  │ • CDC to Delta Lake                                    │   │
│  │ • Streaming to Delta Lake                              │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Query Engines                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Athena: Serverless queries                           │   │
│  │ • Redshift Spectrum: Federated queries                 │   │
│  │ • EMR Spark: Batch processing                          │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q23: How do you implement ETL for compliance?

Answer:

Compliance ETL:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Compliance ETL Architecture                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  GDPR Requirements                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Right to erasure: Delete user data                   │   │
│  │ • Data portability: Export user data                   │   │
│  │ • Consent management: Track consent                    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  HIPAA Requirements                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • PHI encryption                                       │   │
│  │ • Access controls                                      │   │
│  │ • Audit logging                                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  PCI DSS Requirements                                          │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Card data tokenization                               │   │
│  │ • Network segmentation                                 │   │
│  │ • Regular security testing                             │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q24: How do you implement ETL for real-time analytics?

Answer:

Real-Time Analytics ETL:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Real-Time Analytics ETL                            │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Lambda Architecture                                           │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Speed Layer: Kinesis → Lambda (real-time)              │   │
│  │ Batch Layer: EMR/S3 (comprehensive)                    │   │
│  │ Serving: Merged views in Redshift/DynamoDB             │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Streaming ETL                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Kinesis Data Firehose → S3 (raw)                     │   │
│  │ • Lambda (transform) → S3 (processed)                  │   │
│  │ • Athena/Redshift Spectrum (query)                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Latency vs Cost                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ < 1 sec: Kinesis + Lambda ($$$)                        │   │
│  │ < 5 min: Firehose ($$)                                 │   │
│  │ < 1 hour: Batch ETL ($)                                │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q25: How do you implement ETL best practices?

Answer:

ETL Best Practices Checklist:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              ETL Best Practices                                 │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Design Principles                                             │
│  ☐ Idempotent jobs (safe to re-run)                          │   │
│  ☐ Atomic operations (all-or-nothing)                        │   │
│  ☐ Incremental processing (avoid full loads)                 │   │
│  ☐ Separation of concerns (extract, transform, load)         │   │
│                                                                 │
│  Implementation                                                │
│  ☐ Proper error handling and logging                         │   │
│  ☐ Data validation at each stage                             │   │
│  ☐ Monitoring and alerting                                   │   │
│  ☐ Cost optimization                                         │   │
│                                                                 │
│  Operations                                                    │
│  ☐ Documentation (runbooks, data dictionaries)               │   │
│  ☐ Testing (unit, integration, performance)                  │   │
│  ☐ Version control                                           │   │
│  ☐ CI/CD pipeline                                            │   │
│                                                                 │
│  Governance                                                    │
│  ☐ Data lineage tracking                                     │   │
│  ☐ Quality metrics                                           │   │
│  ☐ SLA monitoring                                            │   │
│  ☐ Compliance requirements                                   │   │
└─────────────────────────────────────────────────────────────────┘

Summary

Mastering AWS ETL patterns requires understanding:

ETL vs ELT: When to transform before or after loading
Patterns: Incremental, CDC, real-time, batch
Optimization: Partitioning, file formats, caching
Governance: Testing, monitoring, documentation
Cost: Right-sizing, serverless, Spot instances

These concepts form the foundation for building efficient, scalable data pipelines on AWS.

AWS ETL Patterns Interview Questions

🔄 AWS ETL Patterns Interview

ETL/ELT Patterns Overview

Q1: When should you choose ETL vs ELT?

Q2: How do you design a scalable ETL pipeline?

Q3: How do you handle data quality in ETL pipelines?

Q4: How do you optimize ETL job performance?

Q5: How do you implement incremental ETL?

Q6: How do you handle schema evolution in ETL?

Q7: How do you implement error handling in ETL?

Q8: How do you orchestrate complex ETL workflows?

Q9: How do you test ETL pipelines?

Q10: How do you monitor ETL pipelines?

Q11: How do you implement real-time ETL?

Q12: How do you implement data lake ETL?

Q13: How do you implement data warehouse ETL?

Q14: How do you implement ETL for unstructured data?

Q15: How do you implement ETL for IoT data?

Q16: How do you implement data masking in ETL?

Q17: How do you implement ETL for machine learning?

Q18: How do you implement ETL governance?

Q19: How do you implement ETL cost optimization?

Q20: How do you implement ETL for multiple data sources?

Q21: How do you implement ETL for historical data migration?

Q22: How do you implement ETL for data lakehouse?

Q23: How do you implement ETL for compliance?

Q24: How do you implement ETL for real-time analytics?

Q25: How do you implement ETL best practices?

Summary