Airflow DAG Authoring study plan

Write a minimal DAG file from scratch and explain each top-level component (DAG object, default_args, operator instantiation) without notes

Convert a script-style pipeline into a DAG with four BashOperator and PythonOperator tasks and verify it parses with a DAG bag load

Instantiate the DAG using a context manager and again using explicit dag= arguments, then state two differences in behavior

Set start_date, schedule, catchup, and tags on a DAG and articulate what each controls

Build tasks with PythonOperator, BashOperator, and at least one provider operator, passing arguments correctly to each

Express a fan-out/fan-in dependency graph using both bitshift operators and set_upstream/set_downstream, then compare the two notations

Implement branching with BranchPythonOperator and confirm skipped-branch behavior including trigger rules

Add a TaskGroup to organize related tasks and verify the rendered graph structure

Distinguish logical date, run date, and data interval, and predict the execution_date a daily DAG receives for a given schedule

Configure a DAG with catchup disabled and explain how backfill differs from normal scheduled runs

Push and pull values with XComs using both the return-value convention and explicit xcom_push/xcom_pull

Template a BashOperator command and a PythonOperator argument with ds, data_interval_start, and params, then verify rendering in a task log

Generate multiple DAGs or tasks programmatically from a config list and explain why top-level loop variables must be bound safely

Convert a repeated-task pattern into a dynamically mapped task using expand and partial

Control mapped-task concurrency with max_active_tis_per_dag or map-length limits and describe the effect

Combine mapped tasks with a downstream aggregation task and confirm dependency semantics

Create and reference an Airflow connection by conn_id, then retrieve it in a task through a hook rather than hardcoding credentials

Store and read Airflow Variables at DAG-parse time versus task runtime, and explain the performance implication of each

Pass a small config object through params and templating instead of XCom where appropriate, and justify the choice

Identify three cases where XCom is the wrong tool and propose an alternative for each

Configure retries, retry_delay, and exponential backoff on tasks and predict the resulting attempt timeline

Implement on_failure_callback and on_retry_callback and log structured failure context from each

Set an SLA and explain which timestamp it is measured against and what happens when it is missed

Choose appropriate trigger rules for an error-handling task that must run only after upstream failure

Write DagBag-based tests that assert task count, dependency edges, and absence of import errors

Test a PythonOperator callable in isolation with mocked hooks or connections

Use airflow tasks test to run a single task locally and interpret the output

Diagnose a slow DAG parse caused by top-level database or network calls and refactor it

Audit a DAG against a hygiene checklist covering naming, idempotency, no top-level side effects, and secrets handling

Refactor a DAG to remove duplicated boilerplate using default_args or a shared factory

Verify idempotency by reasoning through a rerun of the same data interval and listing any non-idempotent steps

Produce a final review of all practice DAGs and correct at least three defects found