🔧 Databricks & Spark Interview

Comprehensive interview preparation for Databricks, Apache Spark, Delta Lake, and lakehouse architecture on AWS.

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

Databricks/Spark Architecture Overview

Architecture Diagram

┌─────────────────────────────────────────────────────────────────────┐
│                    Databricks/Spark Architecture                    │
├─────────────────────────────────────────────────────────────────────┤
│                                                                     │
│  Databricks on AWS                                                 │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │ • Managed Spark clusters                                  │   │
│  │ • Delta Lake (ACID transactions)                          │   │
│  │ • Unity Catalog (governance)                              │   │
│  │ • MLflow (ML lifecycle)                                   │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                     │
│  Spark Components                                                 │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │ Driver → Cluster Manager → Executors                      │   │
│  │                                                             │   │
│  │ RDD → DataFrame → Dataset                                  │   │
│  │                                                             │   │
│  │ Spark SQL, Spark Streaming, MLlib, GraphX                  │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                     │
│  Storage Integration                                              │
│  ┌─────────────────────────────────────────────────────────────┐   │
│  │ • S3: Primary storage                                    │   │
│  │ • Delta Lake: ACID layer on S3                           │   │
│  │ • DBFS: Databricks File System (mounts to S3)           │   │
│  └─────────────────────────────────────────────────────────────┘   │
│                                                                     │
└─────────────────────────────────────────────────────────────────────┘

Q1: How does Databricks differ from EMR?

Answer:

Comparison:

Feature	Databricks	EMR
Management	Fully managed	Self-managed clusters
Spark	Optimized runtime	Open-source Spark
UI	Collaborative notebooks	CLI/API
Governance	Unity Catalog	IAM-based
Cost	DBU-based	Instance-based

Choose Databricks when:

Need collaborative notebooks
Require built-in ML tools
Want optimized Spark runtime
Need Unity Catalog governance

Choose EMR when:

Need full cluster control
Custom Spark applications
Long-running clusters
Cost is primary concern

Architecture Diagram

Decision Tree:
┌─────────────────────────────────────────┐
│ Need collaborative notebooks?           │
└────────────────┬────────────────────────┘
                 │
        ┌────────┴────────┐
        ▼                 ▼
       Yes                No
        │                  │
        ▼                  ▼
  ┌───────────┐    ┌───────────────────┐
  │Databricks │    │ Need custom JARs? │
  └───────────┘    └─────────┬─────────┘
                             │
                  ┌──────────┴──────────┐
                  ▼                     ▼
                 Yes                    No
                  │                     │
                  ▼                     ▼
           ┌───────────┐        ┌───────────┐
           │   EMR     │        │Databricks │
           └───────────┘        └───────────┘

Q2: What is Delta Lake and why use it?

Answer:

Delta Lake Features:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Delta Lake Architecture                            │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ACID Transactions                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Atomic: All or nothing                               │   │
│  │ • Consistent: Data integrity                           │   │
│  │ • Isolated: Concurrent reads/writes                    │   │
│  │ • Durable: Persistent storage                          │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Time Travel                                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Version history                                      │   │
│  │ • Query by version/timestamp                           │   │
│  │ • Rollback support                                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Schema Evolution                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Add columns                                          │   │
│  │ • Rename columns                                       │   │
│  │ • Change data types                                    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Performance                                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Z-Order indexing                                     │   │
│  │ • Data skipping                                        │   │
│  │ • Compaction                                           │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Delta Lake Usage:

# Write to Delta Lake
df.write.format("delta").save("/delta/events")

# Read with time travel
df = spark.read.format("delta").option("versionAsOf", 5).load("/delta/events")

# SQL syntax
"""
CREATE TABLE events USING delta LOCATION '/delta/events'
SELECT * FROM delta.`/delta/events`
"""

Q3: How do you optimize Spark job performance?

Answer:

Spark Optimization Techniques:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Spark Performance Optimization                     │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Memory Management                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • spark.executor.memory: 8-16 GB                      │   │
│  │ • spark.memory.fraction: 0.6-0.8                      │   │
│  │ • spark.memory.storageFraction: 0.5                    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Partitioning                                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • spark.sql.shuffle.partitions: 200 (default)          │   │
│  │ • Target: 128MB-1GB per partition                      │   │
│  │ • Use repartition() or coalesce()                      │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Serialization                                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Kryo serializer (faster than Java)                   │   │
│  │ • spark.serializer: org.apache.spark.serializer.KryoSerializer │ │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Caching                                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • cache() / persist() for DataFrames                   │   │
│  │ • unpersist() when no longer needed                    │   │
│  │ • Use appropriate storage level                        │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Spark Configuration:

# Optimal Spark configuration
spark.conf.set("spark.sql.shuffle.partitions", "200")
spark.conf.set("spark.executor.memory", "8g")
spark.conf.set("spark.executor.cores", "4")
spark.conf.set("spark.executor.instances", "10")
spark.conf.set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
spark.conf.set("spark.sql.adaptive.enabled", "true")
spark.conf.set("spark.sql.adaptive.coalescePartitions.enabled", "true")

Q4: How do you handle data skew in Spark?

Answer:

Data Skew Solutions:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Data Skew Handling Strategies                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Detection                                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Check partition sizes                                │   │
│  │ • Monitor task execution times                         │   │
│  │ • Use Spark UI to identify hot partitions              │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Salting Technique                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ df_salted = df.withColumn(                             │   │
│  │     "salt",                                            │   │
│  │     (rand() * 10).cast("int")                          │   │
│  │ ).withColumn(                                          │   │
│  │     "salted_key",                                      │   │
│  │     concat(col("key"), lit("_"), col("salt"))          │   │
│  │ )                                                      │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Broadcast Join                                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ from pyspark.sql.functions import broadcast            │   │
│  │ result = large_df.join(broadcast(small_df), "key")     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  AQE (Adaptive Query Execution)                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ spark.conf.set("spark.sql.adaptive.enabled", "true")  │   │
│  │ spark.conf.set("spark.sql.adaptive.skewJoin.enabled", "true")│
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q5: How do you implement Delta Lake CDC?

Answer:

Delta Lake CDC:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Delta Lake CDC Implementation                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Merge Operation                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ deltaTable.alias("target").merge(                      │   │
│  │     source.alias("source"),                            │   │
│  │     "target.id = source.id"                            │   │
│  │ ).whenMatchedUpdateAll().whenNotMatchedInsertAll().execute()│
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Change Data Feed                                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Enable change data feed                             │   │
│  │ • Query changes by version                             │   │
│  │ • Track insert, update, delete operations              │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Auto Loader                                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Incremental file ingestion                           │   │
│  │ • Schema inference and evolution                       │   │
│  │ • Exactly-once processing                              │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Merge Example:

from delta.tables import DeltaTable

# Load target table
deltaTable = DeltaTable.forPath(spark, "/delta/customers")

# Merge operation
deltaTable.alias("target").merge(
    source.alias("source"),
    "target.customer_id = source.customer_id"
).whenMatchedUpdate(
    set={
        "name": "source.name",
        "email": "source.email",
        "updated_at": "current_timestamp()"
    }
).whenNotMatchedInsert(
    values={
        "customer_id": "source.customer_id",
        "name": "source.name",
        "email": "source.email",
        "created_at": "current_timestamp()"
    }
).execute()

Q6: How do you implement Delta Lake time travel?

Answer:

Time Travel Implementation:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Delta Lake Time Travel                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Query by Version                                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ df = spark.read.format("delta").option(                │   │
│  │     "versionAsOf", 5                                   │   │
│  │ ).load("/delta/events")                                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Query by Timestamp                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ df = spark.read.format("delta").option(                │   │
│  │     "timestampAsOf", "2024-01-15"                     │   │
│  │ ).load("/delta/events")                                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  History                                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ deltaTable.history()                                   │   │
│  │ # Returns version, timestamp, operation, etc.          │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Rollback                                                      │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ deltaTable.restore(5)                                  │   │
│  │ # Restores table to version 5                          │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q7: How do you optimize Delta Lake performance?

Answer:

Delta Lake Optimization:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Delta Lake Performance Optimization                │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Z-Order Indexing                                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ OPTIMIZE events ZORDER BY (event_date, user_id)       │   │
│  │                                                          │   │
│  │ • Co-locate related data                               │   │
│  │ • Improve query performance                            │   │
│  │ • Data skipping enabled                                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Compaction                                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ OPTIMIZE events                                        │   │
│  │                                                          │   │
│  │ • Combine small files                                  │   │
│  │ • Reduce file count                                    │   │
│  │ • Improve read performance                             │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Data Skipping                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Statistics-based pruning                             │   │
│  │ • Min/max values per file                              │   │
│  │ • Automatic with Z-Order                               │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Partitioning                                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ df.write.partitionBy("year", "month")                 │   │
│  │ .format("delta").save("/delta/events")                │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q8: How do you implement Delta Lake schema evolution?

Answer:

Schema Evolution:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Delta Lake Schema Evolution                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Add Columns                                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ df.write.format("delta")                              │   │
│  │ .option("mergeSchema", "true")                        │   │
│  │ .mode("append").save("/delta/events")                 │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Overwrite Schema                                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ df.write.format("delta")                              │   │
│  │ .option("overwriteSchema", "true")                    │   │
│  │ .mode("overwrite").save("/delta/events")              │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  SQL Schema Evolution                                          │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ ALTER TABLE events ADD COLUMN (new_col STRING)         │   │
│  │ ALTER TABLE events ALTER COLUMN old_col RENAME TO new_name│ │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q9: How do you implement streaming with Delta Lake?

Answer:

Delta Lake Streaming:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Delta Lake Streaming Architecture                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Structured Streaming                                          │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ streaming_df = spark.readStream.format("delta")        │   │
│  │ .load("/delta/events")                                 │   │
│  │                                                          │   │
│  │ query = streaming_df.writeStream.format("delta")       │   │
│  │ .outputMode("append")                                 │   │
│  │ .start("/delta/output")                               │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Auto Loader                                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ df = spark.readStream.format("cloudFiles")             │   │
│  │ .option("cloudFiles.format", "json")                  │   │
│  │ .load("s3://bucket/input/")                           │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Output Modes                                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Append: Add new rows                                 │   │
│  │ • Update: Update existing rows                         │   │
│  │ • Complete: Full result table                          │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q10: How do you implement Unity Catalog?

Answer:

Unity Catalog Architecture:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Unity Catalog Architecture                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Three-Level Namespace                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ catalog.schema.table                                   │   │
│  │                                                          │   │
│  │ • Catalog: Top-level grouping                          │   │
│  │ • Schema: Logical grouping (database)                  │   │
│  │ • Table: Data storage                                   │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Access Control                                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • GRANT SELECT ON TABLE catalog.schema.table TO user   │   │
│  │ • Column-level permissions                             │   │
│  │ • Row-level filtering                                  │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Lineage                                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Automatic lineage tracking                           │   │
│  │ • Column-level lineage                                 │   │
│  │ • Integration with governance tools                    │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q11: How do you implement MLflow on Databricks?

Answer:

MLflow Implementation:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              MLflow Architecture                                │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  MLflow Components                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Tracking: Log parameters, metrics, artifacts         │   │
│  │ • Projects: Reproducible ML code                       │   │
│  │ • Models: Model format and serving                     │   │
│  │ • Registry: Model versioning and lifecycle             │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Tracking                                                      │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ mlflow.start_run()                                    │   │
│  │ mlflow.log_param("learning_rate", 0.01)              │   │
│  │ mlflow.log_metric("accuracy", 0.95)                  │   │
│  │ mlflow.log_artifact("model.pkl")                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Model Registry                                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ mlflow.register_model(                                 │   │
│  │     "runs:/run_id/model",                             │   │
│  │     "production_model"                                │   │
│  │ )                                                      │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q12: How do you implement Databricks notebooks?

Answer:

Notebook Best Practices:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Databricks Notebook Best Practices                 │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Organization                                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Use sections and headings                            │   │
│  │ • Add markdown documentation                           │   │
│  │ • Separate ETL, analysis, and visualization            │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Reproducibility                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Use widgets for parameters                           │   │
│  │ • Version control with Git                             │   │
│  │ • Document dependencies                                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Performance                                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Cache DataFrames                                     │   │
│  │ • Use broadcast joins for small tables                 │   │
│  │ • Monitor Spark UI                                     │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Collaboration                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Use comments and documentation                       │   │
│  │ • Share notebooks with teams                           │   │
│  │ • Use version history                                  │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q13: How do you implement Databricks jobs?

Answer:

Databricks Jobs:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Databricks Jobs Architecture                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Job Types                                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Notebook tasks                                       │   │
│  │ • JAR tasks                                            │   │
│  │ • Python shell tasks                                   │   │
│  │ • Spark submit tasks                                   │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Scheduling                                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Cron expressions                                     │   │
│  │ • Dependency chains                                    │   │
│  │ • Retry policies                                       │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Cluster Configuration                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • New cluster (ephemeral)                              │   │
│  │ • Existing cluster (shared)                            │   │
│  │ • Auto-scaling configuration                           │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Monitoring                                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Run history                                          │   │
│  │ • Alerting                                             │   │
│  │ • Logging                                              │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q14: How do you optimize Databricks costs?

Answer:

Databricks Cost Optimization:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Databricks Cost Optimization                       │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Cluster Optimization                                          │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Right-size instance types                            │   │
│  │ • Use spot instances                                   │   │
│  │ • Auto-terminate idle clusters                         │   │
│  │ • Use serverless for notebooks                         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  DBU Optimization                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Use appropriate compute tier                         │   │
│  │ • Optimize job runtimes                                │   │
│  │ • Use cached data                                      │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Storage Optimization                                          │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Delta Lake compaction                                │   │
│  │ • Z-Order indexing                                     │   │
│  │ • File size optimization                               │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Cost Monitoring                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Usage dashboards                                     │   │
│  │ • Budget alerts                                        │   │
│  │ • Cost allocation by team/project                      │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q15: How do you implement data quality in Databricks?

Answer:

Data Quality Implementation:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Databricks Data Quality                            │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Delta Live Tables (DLT)                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ @dlt.table                                             │   │
│  │ def raw_data():                                        │   │
│  │     return spark.read.format("json").load(path)       │   │
│  │                                                          │   │
│  │ @dlt.expect("valid_amount", "amount > 0")             │   │
│  │ def validated_data():                                  │   │
│  │     return dlt.read("raw_data")                       │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Great Expectations                                           │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Integrate with Databricks                            │   │
│  │ • Define expectations                                  │   │
│  │ • Validate data quality                                │   │
│  │ • Generate quality reports                             │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Custom Validation                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Define quality rules                                 │   │
│  │ • Implement validation functions                       │   │
│  │ • Log quality metrics                                  │   │
│  │ • Alert on failures                                    │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q16: How do you implement Databricks security?

Answer:

Databricks Security:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Databricks Security Architecture                   │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Network Security                                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • VPC deployment                                       │   │
│  │ • PrivateLink                                          │   │
│  │ • Security groups                                      │   │
│  │ • IP access lists                                      │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Data Security                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Encryption at rest (SSE)                             │   │
│  │ • Encryption in transit (TLS)                          │   │
│  │ • Unity Catalog access control                         │   │
│  │ • Column-level security                                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Identity & Access                                             │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • SSO integration                                      │   │
│  │ • IAM role mapping                                     │   │
│  │ • SCIM provisioning                                    │   │
│  │ • Multi-factor authentication                          │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Audit                                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Audit logs                                           │   │
│  │ • Unity Catalog audit trail                            │   │
│  │ • AWS CloudTrail integration                           │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q17: How do you implement Databricks CI/CD?

Answer:

Databricks CI/CD:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Databricks CI/CD Architecture                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Source Control                                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Git integration                                      │   │
│  │ • Branch support                                       │   │
│  │ • Commit history                                       │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Databricks Repos                                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Clone Git repos                                     │   │
│  │ • Branch management                                    │   │
│  │ • Commit and push                                      │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Deployment                                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Databricks CLI                                       │   │
│  │ • REST API                                             │   │
│  │ • Terraform provider                                   │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Testing                                                       │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Unit tests                                          │   │
│  │ • Integration tests                                    │   │
│  │ • Data quality tests                                   │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q18: How do you implement Databricks multi-hop architecture?

Answer:

Multi-Hop Architecture:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Databricks Multi-Hop Architecture                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Bronze (Raw)                                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Raw data as-is                                       │   │
│  │ • Schema on read                                       │   │
│  │ • Append-only                                          │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Silver (Validated)                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Cleaned data                                         │   │
│  │ • Schema enforced                                      │   │
│  │ • Deduplicated                                         │   │
│  │ • Validated                                            │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Gold (Business)                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Business-level aggregates                            │   │
│  │ • Dimension/fact tables                                │   │
│  │ • Optimized for queries                                │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Delta Live Tables Implementation                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ @dlt.table                                             │   │
│  │ def bronze():                                          │   │
│  │     return spark.read.stream.format("cloudFiles")     │   │
│  │                                                          │   │
│  │ @dlt.table                                             │   │
│  │ def silver():                                          │   │
│  │     return dlt.read("bronze").filter("is_valid")      │   │
│  │                                                          │   │
│  │ @dlt.table                                             │   │
│  │ def gold():                                            │   │
│  │     return dlt.read("silver").groupBy("category").agg()│  │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q19: How do you implement Databricks for real-time?

Answer:

Real-Time Processing:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Databricks Real-Time Architecture                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Structured Streaming                                          │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Read from Kafka/Kinesis                              │   │
│  │ • Process with Spark                                   │   │
│  │ • Write to Delta Lake                                  │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Delta Live Tables (Streaming)                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ @dlt.table                                             │   │
│  │ def streaming_events():                                │   │
│  │     return spark.readStream.format("cloudFiles")       │   │
│  │     .option("cloudFiles.format", "json")              │   │
│  │     .load("/events/raw")                              │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Latency Options                                               │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Micro-batch: Seconds latency                         │   │
│  │ • Continuous: Millisecond latency                      │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q20: How do you implement Databricks for ML?

Answer:

Databricks ML Architecture:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Databricks ML Architecture                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ML Pipeline                                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Data Prep → Feature Eng → Training → Evaluation → Deploy│   │
│  │                                                          │   │
│  │ • AutoML for quick prototyping                         │   │
│  │ • MLflow for tracking                                  │   │
│  │ • Model Registry for versioning                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Feature Store                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Centralized feature repository                       │   │
│  │ • Online/offline stores                                │   │
│  │ • Feature sharing                                      │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Model Serving                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Real-time endpoints                                  │   │
│  │ • Batch inference                                      │   │
│  │ • A/B testing                                          │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q21: How do you implement Databricks governance?

Answer:

Databricks Governance:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Databricks Governance Framework                    │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Unity Catalog                                                 │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Centralized governance                               │   │
│  │ • Fine-grained access control                          │   │
│  │ • Data lineage                                          │   │
│  │ • Data discovery                                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Access Control                                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • GRANT/REVOKE statements                              │   │
│  │ • Role-based access                                    │   │
│  │ • Column/row-level security                            │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Audit                                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • System table audit logs                              │   │
│  │ • Access history                                       │   │
│  │ • Lineage tracking                                     │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q22: How do you migrate to Databricks?

Answer:

Migration Strategy:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Databricks Migration Strategy                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Assessment                                                     │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Inventory existing workloads                         │   │
│  │ • Identify dependencies                                │   │
│  │ • Estimate costs                                       │   │
│  │ • Plan timeline                                        │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Migration Phases                                              │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ Phase 1: Lift and shift (quick win)                    │   │
│  │ Phase 2: Optimize (performance)                        │   │
│  │ Phase 3: Modernize (Delta Lake, DLT)                   │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Tools                                                         │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Databricks Accelerate                                │   │
│  │ • Migration assessment tools                           │   │
│  │ • Automated code conversion                            │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q23: How do you implement Databricks best practices?

Answer:

Best Practices Checklist:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Databricks Best Practices                          │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Code Organization                                             │
│  ☐ Use Databricks Repos for version control                   │
│  ☐ Modular notebook design                                    │
│  ☐ Use widgets for parameters                                 │
│  ☐ Document code and assumptions                              │
│                                                                 │
│  Performance                                                   │
│  ☐ Cache frequently used DataFrames                           │
│  ☐ Use broadcast joins for small tables                       │
│  ☐ Optimize partition counts                                  │
│  ☐ Use Delta Lake for ACID transactions                       │
│                                                                 │
│  Cost Optimization                                             │
│  ☐ Right-size clusters                                        │
│  ☐ Use spot instances                                         │
│  ☐ Auto-terminate idle clusters                               │
│  ☐ Monitor DBU usage                                          │
│                                                                 │
│  Governance                                                    │
│  ☐ Implement Unity Catalog                                    │
│  ☐ Use access controls                                        │
│  ☐ Enable audit logging                                       │
│  ☐ Track data lineage                                         │
└─────────────────────────────────────────────────────────────────┘

Q24: How do you troubleshoot Databricks issues?

Answer:

Troubleshooting Guide:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Databricks Troubleshooting                         │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Performance Issues                                            │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Check Spark UI for bottlenecks                       │   │
│  │ • Monitor executor memory/disk                         │   │
│  │ • Review shuffle read/write                            │   │
│  │ • Check for data skew                                   │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Cluster Issues                                                │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Check cluster status                                 │   │
│  │ • Review driver/executor logs                          │   │
│  │ • Monitor network connectivity                         │   │
│  │ • Check instance availability                          │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Data Issues                                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Verify data format                                   │   │
│  │ • Check schema compatibility                           │   │
│  │ • Review file sizes                                    │   │
│  │ • Validate data quality                                │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Q25: How do you implement Databricks for data engineering?

Answer:

Data Engineering Best Practices:

Architecture Diagram

┌─────────────────────────────────────────────────────────────────┐
│              Databricks Data Engineering Best Practices         │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Architecture                                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Multi-hop architecture (Bronze/Silver/Gold)          │   │
│  │ • Delta Lake as foundation                             │   │
│  │ • Unity Catalog for governance                         │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  ETL Patterns                                                  │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Delta Live Tables for declarative ETL                │   │
│  │ • Auto Loader for incremental ingestion                │   │
│  │ • Merge for upserts                                    │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Scheduling                                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Databricks Jobs for orchestration                    │   │
│  │ • Dependency chains                                    │   │
│  │ • Retry policies                                       │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                 │
│  Monitoring                                                    │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │ • Job run history                                      │   │
│  │ • Cluster metrics                                      │   │
│  │ • Cost tracking                                        │   │
│  └─────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────┘

Summary

Mastering Databricks and Spark requires understanding:

Architecture: Lakehouse, multi-hop, Delta Lake
Performance: Partitioning, caching, AQE
Governance: Unity Catalog, access control, lineage
ML: MLflow, Feature Store, Model Serving
Cost: Cluster optimization, DBU management

These concepts form the foundation for building scalable data platforms on Databricks/AWS.

AWS Databricks & Spark Interview Questions

🔧 Databricks & Spark Interview

Databricks/Spark Architecture Overview

Q1: How does Databricks differ from EMR?

Q2: What is Delta Lake and why use it?

Q3: How do you optimize Spark job performance?

Q4: How do you handle data skew in Spark?

Q5: How do you implement Delta Lake CDC?

Q6: How do you implement Delta Lake time travel?

Q7: How do you optimize Delta Lake performance?

Q8: How do you implement Delta Lake schema evolution?

Q9: How do you implement streaming with Delta Lake?

Q10: How do you implement Unity Catalog?

Q11: How do you implement MLflow on Databricks?

Q12: How do you implement Databricks notebooks?

Q13: How do you implement Databricks jobs?

Q14: How do you optimize Databricks costs?

Q15: How do you implement data quality in Databricks?

Q16: How do you implement Databricks security?

Q17: How do you implement Databricks CI/CD?

Q18: How do you implement Databricks multi-hop architecture?

Q19: How do you implement Databricks for real-time?

Q20: How do you implement Databricks for ML?

Q21: How do you implement Databricks governance?

Q22: How do you migrate to Databricks?

Q23: How do you implement Databricks best practices?

Q24: How do you troubleshoot Databricks issues?

Q25: How do you implement Databricks for data engineering?

Summary