Free Practice Questions for Airflow Fundamentals

Exam-style questions and explanations by OpenExamPrep.

✓ No registration✓ No credit card

100+ Questions

100% Free

Loading practice questions...

Same family resources

Explore More Astronomer (Apache Airflow) Certifications

Continue into nearby exams from the same family. Each card keeps practice questions, study guides, flashcards, videos, and articles in one place.

Astronomer Certification: Apache Airflow DAG Authoring

Practice Questions100 questions

Exam Review

Key Facts: Airflow Fundamentals Exam

Exam Questions

Astronomer

60 min

Exam Duration

Astronomer

75%

Passing Score

Astronomer

Free

Exam Fee

Astronomer

2 years

Validity

Astronomer

75 questions in 60 minutes, passing score 75%, free to take. Covers Airflow architecture (webserver, scheduler, executor, metadata DB), DAGs and tasks, operators (PythonOperator, BashOperator, sensors), XCom, Variables, Connections, and monitoring. Certification valid for 2 years. Available online.

Sample Airflow Fundamentals Practice Questions

Try these sample questions to review concepts for the Airflow Fundamentals exam. Each question includes a detailed explanation. Start the interactive quiz above for the full 100+ question experience with AI tutoring.

1Which Airflow component is responsible for reading DAG files, determining when tasks are ready to run, and sending them to the executor?

A.Scheduler

B.Webserver

C.Executor

D.Metadata database

Explanation: The Airflow scheduler continuously reads DAG files from the dag_folder, evaluates task dependencies and schedule intervals, and sends ready tasks to the executor. The webserver provides the UI. The executor manages task dispatch to workers. The metadata database stores state.

2What does the Airflow metadata database store?

A.DAG source code files

B.Task instance states, DAG run history, variables, and connections

C.Executor worker logs

D.Python operator return values only

Explanation: The metadata database (typically PostgreSQL or MySQL) stores DAG run records, task instance states, XCom values, Variables, Connections, user info, and other Airflow operational data. DAG source code lives in the dag_folder on the filesystem.

3Which executor is appropriate for a single-machine Airflow deployment with moderate workloads and does NOT require a Celery or Kubernetes infrastructure?

A.SequentialExecutor

B.LocalExecutor

C.CeleryExecutor

D.KubernetesExecutor

Explanation: LocalExecutor runs tasks as subprocesses on the same machine as the scheduler, supporting parallel task execution without external infrastructure. SequentialExecutor runs one task at a time (not suitable for production). CeleryExecutor requires a message broker. KubernetesExecutor requires a Kubernetes cluster.

4In the following DAG snippet, what is the task execution order? ```python extract >> transform >> load ```

A.load → transform → extract

B.extract → transform → load

C.All three run in parallel

D.transform → extract → load

Explanation: The >> operator sets downstream dependencies. extract >> transform >> load means extract runs first, then transform (after extract succeeds), then load (after transform succeeds). This creates a linear pipeline.

5A DAG has start_date = datetime(2026, 1, 1) and schedule_interval='@daily'. It is deployed for the first time on 2026-01-05 with catchup=True. How many DAG runs will Airflow immediately trigger?

A.1 (only the most recent missed run)

B.4 (January 1, 2, 3, and 4)

C.5 (January 1 through 5)

D.0 (Airflow waits for the next scheduled run)

Explanation: With catchup=True, Airflow backfills all missed intervals from start_date to the current date. For @daily from Jan 1 to deployment on Jan 5, the missed intervals are Jan 1–2, Jan 2–3, Jan 3–4, and Jan 4–5, producing 4 DAG runs. Jan 5–6 has not elapsed yet.

6What is the difference between the execution_date and the actual run time of an Airflow task?

A.They are always the same; execution_date is when the task runs

B.execution_date is the logical start of the data interval (schedule period), not the actual run time

C.execution_date is the end of the data interval

D.execution_date is set by the executor when the task starts

Explanation: execution_date (also called logical_date in Airflow 2.2+) represents the start of the scheduling interval — a logical time marker for the data period being processed. The actual wall-clock run time is later, after the interval elapses. For a @daily DAG, the Jan 1 execution_date run actually starts on Jan 2 when the interval completes.

7A PythonOperator task needs to pass a file path string to a downstream task. What is the recommended Airflow mechanism?

A.Write the value to a shared filesystem and hardcode the path

B.Use XCom to push the value and have the downstream task pull it

C.Store it in an Airflow Variable and delete it after the downstream task reads it

D.Pass it as a constructor argument to the downstream operator class

Explanation: XCom (cross-communication) is Airflow's built-in mechanism for passing small data between tasks. The upstream task pushes a value (via return or xcom_push), and the downstream task pulls it (via xcom_pull). This keeps task communication traceable and integrated with the metadata database.

8How does a PythonOperator task push a value to XCom using the recommended modern approach?

A.Call context['ti'].xcom_push(key='result', value=my_value) explicitly

B.Return the value from the Python callable — Airflow automatically pushes return values to XCom

C.Write the value to an Airflow Variable with the task ID as the key

D.Call XCom.set(key='result', value=my_value) as a class method

Explanation: When a PythonOperator callable returns a value, Airflow automatically stores it in XCom under the key 'return_value'. This is the cleanest approach and works seamlessly with the TaskFlow API's @task decorator. Explicit xcom_push is also valid but more verbose.

9What is the correct way to retrieve an XCom value pushed by a task with task_id='extract' in a downstream PythonOperator?

A.value = context['xcom']['extract']['return_value']

B.value = ti.xcom_pull(task_ids='extract')

C.value = Variable.get('extract')

D.value = XCom.get(task_id='extract')

Explanation: xcom_pull(task_ids='extract') retrieves the XCom value pushed by the 'extract' task (defaults to 'return_value' key). The TaskInstance (ti) is passed via op_kwargs={'ti': '{{ ti }}'} or via **context when provide_context=True. In the TaskFlow API, XCom pull happens automatically via function arguments.

10An Airflow Variable stores a database connection string that should differ between development and production environments. What is the recommended approach?

A.Hardcode the connection string in the DAG Python file

B.Use an Airflow Variable with the same key, setting different values per environment

C.Create separate DAG files for each environment

D.Store the value in XCom at DAG startup

Explanation: Airflow Variables are environment-specific key-value pairs stored in the metadata database. The DAG code references the key (e.g., Variable.get('db_connection')), and the value is set differently in each environment (dev/prod). This keeps DAG code environment-agnostic. Alternatively, Connections are preferable for actual credentials.

About the Airflow Fundamentals Exam

The Astronomer Certification for Apache Airflow Fundamentals validates knowledge of core Apache Airflow concepts including architecture components, DAG definition, task dependencies, operators, sensors, XCom, Variables, Connections, and the Airflow UI. It is the entry-level Astronomer certification for data engineers and data professionals working with workflow orchestration.

Exam sponsor: Astronomer. The requirements and fees below concern the certification or admission exam, separate from our free practice resources.

Questions

75 questions

Time Limit

60 minutes

Passing Score

75% (56/75)

Exam / Certification Fees

Free

Exam sponsor website

Reported exam pass rate: ~70-80%. for well-prepared candidates (industry estimate) This describes exam candidates, not OpenExamPrep users or results from using our resources. Exam sponsor website

Fees, eligibility, and exam policies can change. Confirm them with the exam sponsor before applying or paying.

Official sources

Our practice resources: topics covered

We aim to reflect publicly available exam outlines and topic information in our study resources. Coverage, format, and difficulty may differ from the actual exam, and we cannot guarantee that every detail is accurate or current. Confirm exam requirements, fees, and policies with the official exam sponsor.

20%

Core Airflow Architecture

Webserver, scheduler, executor types (LocalExecutor, CeleryExecutor, KubernetesExecutor), metadata database, worker, and Airflow component interaction

25%

DAGs and Tasks

DAG definition with Python, task dependencies (>>/<< operators, set_upstream/set_downstream), execution dates, logical dates, schedule intervals, catchup, backfill

25%

Operators and Sensors

PythonOperator, BashOperator, EmailOperator, DummyOperator/EmptyOperator, sensors (FileSensor, HttpSensor), operator parameters (retries, retry_delay, depends_on_past)

20%

XCom, Variables, and Connections

XCom push (xcom_push / return value) and pull, Variables for runtime configuration, Connections and Hooks for external systems

10%

Task Lifecycle and Monitoring

Task states (queued, running, success, failed, skipped, up_for_retry), SLA miss callbacks, log access, Airflow UI Graph and Tree views, triggering DAGs

Preparing for the Airflow Fundamentals Exam

What You Need to Know

Passing score: 75% (56/75)
Exam length: 75 questions
Time limit: 60 minutes
Exam / certification fees: Free Official sources

Using Our Practice Resources

Work through all 100 available questions
Review every answer and explanation
Track weak areas and revisit them
Use our AI tutor for tough concepts

Airflow Fundamentals: Suggested Study Strategy

1Understand the role of each Airflow component: webserver (UI), scheduler (orchestration), executor (task dispatch), metadata DB (state storage)

2Practice writing DAGs with Python — know how to set task dependencies using >> and << operators

3Know the difference between execution_date (logical date) and the actual date a task runs

4Understand catchup=False vs catchup=True and when to use each

5Learn XCom: push via return value or xcom_push, pull via xcom_pull with task_ids parameter

6Know when to use Variables vs environment variables vs Airflow Connections

7Understand task states and what causes each: success, failed, up_for_retry, skipped

Frequently Asked Questions

What is the Airflow scheduler responsible for?

The Airflow scheduler reads DAG files, determines which tasks are ready to run based on dependencies and schedule, and sends tasks to the executor. It continuously monitors DAG runs and task states to keep pipelines moving forward.

What is XCom in Apache Airflow?

XCom (cross-communication) is the mechanism for passing small amounts of data between tasks in the same DAG run. Tasks can push values via xcom_push() or by returning a value, and pull them via xcom_pull(). XCom data is stored in the metadata database and should only be used for small data like identifiers or status flags.

What is the difference between schedule_interval and catchup?

schedule_interval defines how often a DAG runs (e.g., @daily, @hourly, cron expression). catchup=True (default) causes Airflow to backfill all missed runs since the start_date. Setting catchup=False runs only the most recent missed interval, preventing large backlogs of historical runs.

What are Airflow Connections used for?

Connections store credentials and endpoint information for external systems (databases, cloud services, APIs). They are managed through the Airflow UI or environment variables and accessed in tasks via Hooks, which provide convenient interfaces to interact with connected services.