GH-200 — GitHub Actions (GH-200) Exam Study Plan

How to use this Study Plan

This Study Plan is for candidates preparing for the GitHub GitHub Actions (GH-200) exam, code GH-200. It is built around practical workflow knowledge: reading YAML, predicting workflow behavior, choosing triggers, securing automation, troubleshooting failed runs, and understanding how GitHub Actions fits into CI/CD.

Use the plan that matches your available time. If you are close to exam day, prioritize diagnostic practice, weak-area review, and timed mocks. If you are starting earlier, build a small practice repository and test the concepts instead of only reading about them.

Which plan should you use?

What to schedule for GH-200 preparation

The GH-200 exam is about GitHub Actions, so your study time should not be only memorization. You should be able to read workflow files, reason through event behavior, identify security risks, and troubleshoot failed automation.

Daily practice rhythm

Use the same rhythm regardless of your timeline. Adjust the length, not the sequence.

If you have 45 minutes

If you have 90 minutes

If you have 2 hours or more

Missed-question review method

Do not only mark questions as right or wrong. For GH-200, the important step is finding why your mental model failed.

Use this review table after every practice session.

Common missed-question causes:

Baseline diagnostic before you start

Before choosing daily topics, take a short diagnostic set or one small timed quiz.

Do not use the diagnostic to judge whether you are “ready.” Use it to decide where to spend time.

7-day final review sprint

Use this plan if your exam is one week away. It assumes you have already studied GitHub Actions and now need structured review.

Stop adding large new topics after Day 5. Days 6 and 7 are for review, confidence, timing, and error reduction.

7-day priority order

If time is very limited, study in this order:

1. Security and permissions.
2. Trigger behavior and workflow events.
3. Jobs, dependencies, matrices, and reusable workflows.
4. Secrets, variables, environments, and deployments.
5. Artifacts, caching, and troubleshooting.
6. Administration and governance scenarios.

14-day focused plan

Use this plan if you have two weeks and can study most days. The goal is to cover the core GH-200 skills, run targeted labs, and complete at least one timed mock review cycle.

30-day balanced plan

Use this plan if you have about one month. It gives you enough time to learn, lab, review, and improve timing.

Week 1: Build the foundation

Week 2: Control flow, reuse, and data movement

Week 3: Security, deployments, and governance

Week 4: Troubleshooting and final readiness

60/90-day full preparation path

Use this path if you are starting early, are new to GitHub Actions, or need more hands-on practice.

60-day version

90-day version

For a 90-day schedule, stretch the 60-day path and add review loops.

A 90-day candidate should still use the final 14 days as a focused exam-prep block. Do not let the longer timeline delay timed practice.

Hands-on practice checklist

Create a small private practice repository and build workflows that cover the common GH-200 scenarios. Keep each lab short and write down what happened.

Compact workflow example to study

Use small examples like this to practice reading workflow behavior. Do not memorize this file; explain each line.

name: ci

on:
  pull_request:
    branches:
      - main
  workflow_dispatch:

permissions:
  contents: read

concurrency:
  group: ci-${{ github.ref }}
  cancel-in-progress: true

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        node-version: [18, 20]
    steps:
      - uses: actions/checkout@v4

      - name: Set up Node
        uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
          cache: npm

      - name: Install dependencies
        run: npm ci

      - name: Run tests
        run: npm test

Questions to ask when reviewing any workflow:

1. What event starts it?
2. Are branch or path filters involved?
3. What token permissions are granted?
4. What jobs run in parallel?
5. What jobs depend on other jobs?
6. Which values come from contexts, inputs, variables, or secrets?
7. Could this expose secrets to untrusted code?
8. What artifact, cache, or deployment state is created?
9. What would you check first if it failed?

High-yield comparison tables

Cache vs artifact

Secret vs variable

Composite action vs reusable workflow

pull_request vs pull_request_target

For exam scenarios, always ask whether code is trusted before choosing an event or granting secrets.

Timed mock exam strategy

Timed practice should start earlier than the final week. Waiting too long hides pacing and question-reading problems.

During a timed mock:

1. Answer easier questions first if the platform allows navigation.
2. Flag questions where two options seem plausible.
3. Do not change answers unless you find a specific reason.
4. After the mock, review:
   • wrong answers,
   • correct guesses,
   • slow questions,
   • questions missed because of wording.

Troubleshooting review checklist

GH-200 candidates should be comfortable diagnosing why a workflow did not behave as expected.

Useful GitHub CLI commands for hands-on review, if you use the GitHub CLI:

gh workflow list
gh workflow run ci.yml
gh run list
gh run view --log
gh run rerun

Security review checklist

Security is a major practical theme in GitHub Actions preparation. Review it repeatedly.

When to stop adding new material

The final days should improve accuracy, not create new confusion.

Final-week rules

Use these rules during the last week for any timeline.

1. Review missed questions every day.
2. Rework questions before reading the explanation.
3. Keep a one-page list of:
   • trigger rules,
   • security traps,
   • reusable workflow patterns,
   • cache vs artifact differences,
   • troubleshooting checks.
4. Do at least one timed session under realistic conditions.
5. Do not judge readiness only by raw score; inspect whether misses are repeated or isolated.
6. Sleep and pacing matter. Avoid a late-night cram session before the exam.

Exam-readiness checks

You are in a good position for the GitHub Actions (GH-200) exam when you can do the following without relying on notes.

Practical next step

Choose the schedule that matches your exam date, take a diagnostic practice set, and build your weak-area list today. Then study in short daily cycles: review misses, practice one GitHub Actions topic, complete hands-on workflow work, and finish with timed questions.