Data Engineering · Intermediate

Data Pipelines and Orchestration

Build reliable batch ETL and ELT pipelines with Python, Airflow, and dbt, using incremental loads, idempotent design, testing, lineage, and lakehouse storage formats.
LevelIntermediateDuration16 hoursFormatLive online cohortSchedule8 live online sessions x 2 hours, including guided hands-on lab time in every session

Course overview

What you'll learn

Data Pipelines and Orchestration teaches the engineering habits that keep scheduled data work trustworthy. You build extract, load, and transform steps in Python, schedule them in Airflow, load only what changed, and make every rerun safe. You also work with cloud object storage and open table formats, and add tests, lineage, and monitoring so failures surface quickly.

Who it's for

Data Engineers, Analytics Engineers, Backend Developers, Platform Engineers

By the end you will be able to

  • Build extract, transform, and load steps in Python with clear separation between configuration, logic, and I/O
  • Choose between ETL and ELT and justify the choice for a given workload
  • Implement incremental loads using watermarks and merge or upsert patterns
  • Design tasks to be idempotent so retries and backfills are safe
  • Author Airflow DAGs with dependencies, retries, sensors, and parameterized scheduling
  • Write data files as partitioned Parquet and manage tables with Delta Lake or Apache Iceberg

Industry use cases

Examples from the work you do

E-commerce

Load daily order and inventory extracts incrementally into a warehouse, with reruns that never create duplicate rows.

Fintech

Orchestrate end-of-day ledger exports with dependency checks and alerting so downstream reconciliation starts only on complete data.

Healthcare IT

Ingest partner file drops into partitioned Parquet storage with schema validation and a quarantine area for bad files.

Media

Maintain a lakehouse table of viewing events using Delta Lake or Iceberg, with time travel to audit and repair past loads.

Logistics

Backfill several months of shipment data after a bug fix using parameterized, date-partitioned tasks.

SaaS

Combine ELT loads and dbt models in one Airflow DAG, with lineage and data quality checks surfaced to the analytics team.

Syllabus

7 modules, 16 hours.

Every module ends with a hands-on lab you can apply to your own work.

01Pipeline Design Fundamentals2 hours

Understand the building blocks of a data pipeline and the design choices that decide whether it stays reliable.

  • Sources, sinks, and the extract-transform-load lifecycle
  • ETL versus ELT and where transformation should run
  • Batch versus micro-batch versus streaming at a high level
  • Raw, staged, and curated data layers (medallion-style layouts)
  • Configuration, secrets, and environment separation
  • Failure modes: late data, schema drift, and partial loads

Hands-on lab: Sketch a pipeline for a chosen source system, then implement a minimal extract-and-load script in Python that reads from a REST API and lands raw JSON files.

02Python for Data Extraction and Transformation2 hours

Write extraction and transformation code that is testable, observable, and resilient to upstream problems.

  • Reading from APIs, databases, and files with pagination and rate limits
  • Retries with exponential backoff
  • Transformations with pandas and typed validation models
  • Structured logging and meaningful error messages
  • Unit testing transformation functions with pytest
  • Packaging pipeline code as an installable module

Hands-on lab: Refactor a single script into small testable functions, add retry logic and pytest cases for malformed records, and run the suite locally.

03Incremental Loads and Idempotency2 hours

Load only what changed and make every run safe to repeat.

  • Full refresh versus incremental loading
  • High-watermark columns and their weaknesses
  • Change data capture concepts at a high level
  • MERGE and upsert patterns
  • Delete-and-insert by partition as an idempotent strategy
  • Handling late-arriving and duplicate records

Hands-on lab: Implement a watermark-based incremental load into Postgres, run it three times with overlapping data, and prove with a query that no duplicates appear.

04Orchestration with Apache Airflow2 hours

Schedule, order, and recover workflows using Airflow's core concepts.

  • DAGs, tasks, operators, and the TaskFlow API
  • Schedules, logical dates, and data intervals
  • Dependencies, trigger rules, and branching
  • Retries, timeouts, and failure callbacks
  • Sensors and dataset-driven scheduling
  • Variables, connections, and managing secrets

Hands-on lab: Run Airflow locally in Docker, convert your extract-and-load script into a three-task DAG with retries, and trigger it for a past date range.

05Cloud Storage and Lakehouse Formats2 hours

Store data in open, efficient formats and understand what table formats add on top of files.

  • Object storage layout and partitioning conventions on Amazon S3 and similar services
  • Row-oriented versus columnar formats: CSV, JSON, Avro, and Parquet
  • Parquet row groups, compression, and predicate pushdown
  • What Delta Lake and Apache Iceberg add: ACID transactions, schema evolution, and time travel
  • Small-file problems and compaction
  • Choosing a table format and catalog

Hands-on lab: Write the same dataset as CSV and partitioned Parquet, compare size and query time, then create a Delta or Iceberg table and use time travel to read a previous version.

06ELT with dbt and Airflow Together3 hours

Pair orchestration with in-warehouse transformation, and prepare the result for deployment.

  • Loading raw data first, transforming inside the warehouse
  • Triggering dbt runs from Airflow
  • Incremental dbt models and full-refresh handling
  • Backfills and parameterized runs
  • Deploying DAGs through CI and promoting from development to production
  • Managed Airflow options such as Amazon MWAA and Cloud Composer

Hands-on lab: Extend your DAG so that after loading raw data it runs a dbt project that builds an incremental model, perform a backfill across a week of dates, and add a CI check that validates the DAG imports cleanly.

07Testing, Lineage and Observability3 hours

Make pipeline health visible and catch data problems before consumers do.

  • Data quality checks: row counts, nulls, uniqueness, and freshness
  • Great Expectations and dbt tests compared
  • Pipeline unit and integration testing strategies
  • Lineage concepts and OpenLineage events
  • Metrics, logs, and alerting for failed or slow runs
  • Service level objectives for data freshness and runbooks for on-call response

Hands-on lab: Add data quality checks that fail a DAG on bad input, wire a failure alert, and inspect the lineage graph of your pipeline.

Capstone project

Build something you'll use

Build an end-to-end batch pipeline for a public dataset or an anonymized scenario: Python extraction to partitioned Parquet or Delta storage, an incremental load into a warehouse, dbt models, an Airflow DAG with retries and alerts, and data quality checks. You demonstrate a safe rerun and a backfill, and walk the cohort through your design decisions.

Tools and requirements

What you'll work with

PythonApache Airflowdbt CorepandasApache ParquetDelta LakeApache IcebergAmazon S3Great ExpectationsOpenLineageDockerGit

Prerequisites

  • Working proficiency in Python, including functions, packages, and virtual environments
  • Solid SQL fundamentals, including joins and aggregations
  • Comfort with the command line, Git, and basic Docker usage

Frequently asked questions

Before you book.

How do I book this course?

Select "Book a seat" and complete the short form. We email you the next cohort dates, timings and fees, and your seat is secured when you confirm. Requesting a seat is free.

How is the course delivered?

Live and online. The 16 hours run as 8 live online sessions x 2 hours, including guided hands-on lab time in every session, led by an instructor, with hands-on labs in every session.

What do I need to join?

Working proficiency in Python, including functions, packages, and virtual environments Solid SQL fundamentals, including joins and aggregations Comfort with the command line, Git, and basic Docker usage

Can my team take this course together?

Yes. We can run this course for a team with examples from your own roles and tools. Send a team request through the contact page.

Continue exploring

Related courses.

Live online

AI for Engineers

RAG and Vector Search Systems

Build retrieval-augmented generation systems with embeddings, vector databases, hybrid search, and reranking, and learn to evaluate and run them in production.

Advanced16 hours

Ready to start?

Join the next Data Pipelines and Orchestration cohort.

Book a seat
Book your seat