Medallion architecture (bronze, silver, gold) in Apache Spark - Time & Space Complexity
We want to understand how the time to process data grows as the data size increases in the medallion architecture.
How does the processing time change when moving data through bronze, silver, and gold layers?
Analyze the time complexity of the following Apache Spark code snippet.
// Read raw data into bronze layer
val bronzeDF = spark.read.format("json").load("/data/bronze")
// Clean and filter data for silver layer
val silverDF = bronzeDF.filter("value IS NOT NULL")
.dropDuplicates()
// Aggregate for gold layer
val goldDF = silverDF.groupBy("category").count()
This code reads raw data, cleans it, and then aggregates it in three steps representing bronze, silver, and gold layers.
Identify the loops, recursion, array traversals that repeat.
- Primary operation: Data scanning and transformations on the dataset at each layer.
- How many times: Each operation processes all rows once per layer (bronze, silver, gold).
As the input data size grows, each layer processes all rows, so the total work grows roughly in proportion to the data size.
| Input Size (n) | Approx. Operations |
|---|---|
| 10 | About 30 (3 layers x 10 rows) |
| 100 | About 300 (3 layers x 100 rows) |
| 1000 | About 3000 (3 layers x 1000 rows) |
Pattern observation: The total operations grow linearly with input size, multiplied by the number of layers.
Time Complexity: O(n)
This means the processing time grows roughly in direct proportion to the amount of data.
[X] Wrong: "Because there are three layers, the time complexity is cubic or grows much faster than the data size."
[OK] Correct: Each layer processes the data once, so the total work adds up linearly, not multiplies exponentially.
Understanding how data flows through layers and how processing time scales helps you explain real-world data pipelines clearly and confidently.
"What if the silver layer included a join with another large dataset? How would the time complexity change?"
Practice
bronze layer in the Medallion architecture?Solution
Step 1: Understand the role of the bronze layer
The bronze layer is the first stage where raw data is ingested without transformation.Step 2: Differentiate from silver and gold layers
Silver contains cleaned data, and gold contains aggregated data, so they are not raw.Final Answer:
Store raw, unprocessed data as it arrives -> Option CQuick Check:
Bronze = Raw data [OK]
- Confusing bronze with silver or gold layers
- Thinking bronze stores aggregated data
- Assuming bronze is cleaned data
Solution
Step 1: Recall the Medallion architecture flow
Data flows from raw to cleaned to aggregated: bronze, then silver, then gold.Step 2: Match the order to options
Bronze -> Silver -> Gold correctly lists bronze first, then silver, then gold.Final Answer:
Bronze -> Silver -> Gold -> Option AQuick Check:
Order = Bronze, Silver, Gold [OK]
- Reversing the order of layers
- Mixing silver and bronze positions
- Assuming gold comes before silver
bronzeDF = spark.read.format('json').load('/data/raw/events')
silverDF = bronzeDF.filter('event_type IS NOT NULL').dropDuplicates()
goldDF = silverDF.groupBy('event_type').count()Solution
Step 1: Analyze each DataFrame's transformation
bronzeDF loads raw JSON data (raw data = bronze). silverDF filters and removes duplicates (cleaned data = silver). goldDF groups and counts (aggregated data = gold).Step 2: Identify the layer of goldDF
goldDF performs aggregation, which matches the gold layer's purpose.Final Answer:
goldDF is gold layer -> Option AQuick Check:
Aggregation = Gold layer [OK]
- Confusing raw load as silver
- Thinking filtering is aggregation
- Mixing up silver and gold transformations
Solution
Step 1: Understand where duplicates should be removed
Duplicates should be removed during cleaning, which happens in the silver layer.Step 2: Evaluate options for removing duplicates
Adding.dropDuplicates()in silver layer after cleaning transformations is the correct fix.Final Answer:
Add.dropDuplicates()after cleaning transformations in silver layer -> Option BQuick Check:
Remove duplicates in silver layer [OK]
- Removing duplicates too early in bronze layer
- Using groupBy instead of dropDuplicates
- Filtering duplicates only in gold layer
Solution
Step 1: Identify the dashboard data needs
The dashboard requires aggregated, business-ready data (total sales by region).Step 2: Match data needs to Medallion layers
Gold layer contains aggregated and business-level data, ideal for dashboards.Final Answer:
Query the gold layer for aggregated sales data -> Option DQuick Check:
Dashboard needs gold layer data [OK]
- Using raw or cleaned data instead of aggregated
- Querying bronze layer directly for reports
- Filtering bronze layer instead of using gold
Ready to prove it?
Pass the test and this pattern moves unknown
