Etl Throughput Sizing Assistant
Size an ETL pipeline from data volume, processing window, workers and record size: required MB/s, records per second, memory, CPU cores and IOPS.
Etl Throughput Sizing Assistant
Calculator
Adjust values & calculateEnter your values below. Every result is computed in your browser — no data is sent to any server.
Formula: Throughput = (DataVolume * ComplexityFactor) / (Window * Workers); Memory = Workers * (64MB + 2 * BatchSize * Complexity)
Worked example — Feasible with 4 workers, 5 CPU cores, 0.3GB RAM and about 205 IOPS. Estimated cost: ~$1.11 per run on cloud compute.
Formula
Throughput = (DataVolume * ComplexityFactor) / (Window * Workers); Memory = Workers * (64MB + 2 * BatchSize * Complexity)
Calculates required throughput by dividing data volume by the processing window, then multiplying by a complexity factor that accounts for transformation overhead (1.2x for light, 2x for medium, 3.5x for heavy). Memory is estimated per worker based on base allocation plus batch buffer and transform state. Parallelism divides the workload across workers with near-linear scaling.
Worked Examples
Example 1: Nightly Data Warehouse Load
Problem:Load 100GB of transactional data with medium-complexity transforms in a 4-hour nightly window using 4 parallel workers.
Solution:Total records = (100 * 1024 * 1024) / 2 = 52,428,800 records Raw throughput = (100 * 1024) / (4 * 3600) = 7.11 MB/s Effective throughput = 7.11 * 2.0 (medium) = 14.22 MB/s Records/sec = 52,428,800 / 14,400 = 3,641 rec/s Per worker: 3.56 MB/s, 910 rec/s Memory per worker = 64 + (1000 * 2 / 1024) * 2 * 2.0 = 64 + 7.8 = 71.8 MB Memory total = 4 * 71.8 / 1024 = ~0.3 GB Cores: 4 + 1 = 5 IOPS at 64 KB blocks: 7.11 * 1024 / 64 = 114 read + 91 write = 205 total
Result:Feasible with 4 workers, 5 CPU cores, 0.3GB RAM and about 205 IOPS. Estimated cost: ~$1.11 per run on cloud compute.
Example 2: Real-Time Micro-Batch Pipeline
Problem:Process 10GB of event data per hour with heavy transforms (ML scoring) using 8 workers.
Solution:Raw throughput = (10 * 1024) / 3600 = 2.84 MB/s Effective with heavy transforms (3.5x) = 9.96 MB/s Records (0.5KB each) = 20,971,520 records/hour = 5,826 rec/s Per worker: 1.25 MB/s, 728 rec/s Memory per worker = 64 + (1000 * 0.5 / 1024) * 2 * 3.5 = 64 + 3.4 = 67.4 MB Memory total = 8 * 67.4 / 1024 = ~0.5 GB Cores: 8 + 2 = 10 IOPS at 64 KB blocks: 2.84 * 1024 / 64 = 46 read + 37 write = 83 total
Result:Requires 10 CPU cores, 0.5GB RAM and about 83 IOPS. Heavy ML transforms are the bottleneck — consider pre-computing features.
Frequently Asked Questions
How do you calculate ETL throughput requirements?
ETL throughput is calculated by dividing the total data volume by the available processing window. For example, 100GB of data in a 4-hour window requires 100GB / (4 * 3600 seconds) = 7.1 MB/s raw throughput. However, transformations add significant overhead — a medium-complexity transformation (joins, aggregations, type conversions) typically doubles the effective data moved, requiring 14.2 MB/s of processing capacity. Heavy transformations involving machine learning scoring, complex lookups, or data quality checks can multiply this by 3-6x. Always size for peak throughput plus a 20-30% buffer to account for variability in data distribution and system load.
How many parallel workers should an ETL pipeline use?
The optimal number of parallel workers depends on data volume, transformation complexity, and available resources. As a rule of thumb, start with one worker per 25GB of data for medium-complexity transformations. Adding workers provides near-linear scaling up to the point where I/O or network becomes the bottleneck. For most setups, 4-16 workers handle typical enterprise workloads efficiently. Beyond 16 workers, coordination overhead starts to offset parallelism gains. Key constraints include: source database connection limits, target system write capacity, available CPU cores (at least 1 per worker), and memory (each worker needs its own buffer space). Monitor actual utilization to fine-tune.
How much memory does an ETL pipeline need?
ETL memory requirements depend on worker count, batch size, record size, and transformation complexity. Each worker needs a base allocation (typically 64-128MB for framework overhead) plus buffer memory for read/write batches, plus transformation state (hash tables for lookups, aggregation buffers, sort memory). For medium-complexity transforms, plan for 200-500MB per worker. Heavy transforms with large dimension lookups can need 1-2GB per worker. A 4-worker pipeline with medium transforms typically needs 2-4GB total. The biggest memory consumers are hash join operations and in-memory lookup tables — consider switching to disk-based approaches if these exceed available memory. Note that the figure this page reports is deliberately narrower than those planning numbers: it counts only the framework base plus buffered batches (64 MB + 2 × batch size × complexity), which for 2 KB records at medium complexity is about 72 MB per worker. Treat it as a floor for buffer allocation, and add your own lookup tables, sort areas and join state on top.
What IOPS are needed for ETL workloads?
ETL workloads are typically sequential I/O heavy, which is more forgiving than random I/O. Read IOPS can be estimated by dividing throughput by block size: at 7 MB/s with 64KB blocks, you need about 112 read IOPS. Write IOPS are typically 60-80% of read IOPS due to aggregation reducing output volume. For SSDs, these numbers are easily achievable (modern SSDs deliver 50,000+ IOPS). For HDDs, sequential throughput is the limiting factor — a single HDD delivers 100-150 MB/s sequential. Cloud storage (S3, GCS) has different characteristics: high throughput but higher latency per request, making larger batch sizes more important. For data lakes, partition your data to enable parallel file reads.
How do you estimate ETL cloud compute costs?
Cloud ETL costs have three main components: compute (CPU), memory, and data transfer. On AWS, a c5.xlarge (4 vCPU, 8GB RAM) costs about $0.17/hour and can handle 25-50 MB/s of medium-complexity transformation. For 100GB of data in 4 hours, you might need 2-4 such instances at a cost of $1.36-$2.72 per run. Data transfer within the same region is free, but cross-region costs $0.02/GB. Managed ETL services (AWS Glue, Azure Data Factory) charge per DPU-hour ($0.44/DPU-hour for Glue). A common pattern is running on spot instances (60-80% discount) for fault-tolerant ETL jobs with retry logic, reducing costs to $0.50-$1.00 per run for moderate workloads.
What is the difference between ETL and ELT and how does it change sizing?
ETL transforms data in a dedicated engine before loading it; ELT lands raw data in the warehouse and transforms it there in SQL. The arithmetic on this page sizes the ETL shape: workers, memory per worker, and a transform multiplier. Under ELT the extract and load legs still need throughput and IOPS, but the transform cost moves to warehouse compute billed in credits, slots, or DPU-hours, and memory tuning becomes the warehouse engine problem. ETL still wins when the logic needs libraries the warehouse cannot run, or when raw data must not land.
How does data skew break the assumption of near-linear worker scaling?
Parallel scaling assumes each worker receives a comparable share of the work. Skew breaks that: when one join key or partition holds most of the rows, a single task runs long after the others have finished, so wall-clock time is set by the largest partition rather than the average, and adding workers changes nothing. The signs are a long tail in the task duration histogram and one executor pinned at full memory. Remedies include salting the hot key with a random suffix, repartitioning on a higher-cardinality column, and broadcasting a small dimension table so the join needs no shuffle.
How does Little's Law connect batch size to buffer memory in a pipeline?
Little's Law says the average number of items in a system equals arrival rate multiplied by average time in system. For a pipeline, in-flight records equal throughput times end-to-end latency, which is what sets the buffer you must reserve. At 3,641 records per second with two seconds of processing latency, roughly 7,300 records are resident at any instant. Increasing batch size raises throughput by amortizing per-batch overhead, but it raises latency and in-flight memory in the same proportion, so buffer sizing has to move with it.
Why can a 100 GB source occupy far more than 100 GB of worker memory?
Because the volume you quote is normally the compressed on-disk size. Columnar formats such as Parquet and ORC store values encoded and compressed; decoding them into rows, objects, or Arrow batches expands the footprint several times over, and runtimes that box every field add per-object overhead on top. The record size entered here is the decoded size, so the working set can be a multiple of what you read from object storage. Measure the expansion on one sample partition before fixing worker heap, and use projection pushdown so only the needed columns are ever decoded.
When should a pipeline switch from full reloads to change data capture?
A full reload rewrites the entire dataset each run. It is simple and self-correcting, but it sizes the processing window against total table size, so the window eventually stops fitting. Change data capture reads the database transaction log instead, the write-ahead log in Postgres or the binary log in MySQL, so volume tracks the change rate rather than the table size. Switch once daily changes are a small fraction of the table. Keep the load idempotent, usually by upserting on a primary key, so a retried batch after a failure cannot double-count rows.
References
Background & Theory
History
Reviewed for accuracy by Daniel Agrici, Founder & Lead Developer · Editorial policy
Related Calculators
📉Packet Loss Throughput Impact
Calculate TCP throughput under packet loss conditions
📋WIP Limit Kanban Throughput
Calculate Cycle Time and Flow Efficiency using Little's Law
🧮Experiment Design Assistant: Sample Size & Power
Calculate experiment design assistant with inputs, formulas, and instant results.
🧮Color Palette Balance AI
Calculate color palette balance ai with inputs, formulas, and instant results.
🧮EV Route Charge Planner Range AI
Calculate ev route charge planner range ai with inputs, formulas, and instant results.
🧮Work Break Pomodoro Planner AI
Calculate work break pomodoro planner ai with inputs, formulas, and instant results.
🧮3D Print Time Support Estimator
Calculate 3d print time support estimator with inputs, formulas, and instant results.
🧮A B Test Significance Power Analyzer
Calculate a b test significance power analyzer with inputs, formulas, and instant results.