GH-200 course and practice exam: GitHub Actions
This GH-200 course has 31 video lessons and 64 graded labs, and its GH-200 practice exam follows the official exam objectives: a 20-question sampler free with an account, the full question bank and timed mock exams with Pro.
Author, consume and manage workflows and actions
Prepares you for GH-200: authoring and maintaining workflows, consuming workflows, authoring actions, and managing GitHub Actions for an enterprise.
Intermediate · 3 hours · 31 lessons · 78 labs
GH-200 exam guide
The GH-200 exam (GitHub Actions, by GitHub / Microsoft): 100 minutes; pass mark: 700 out of 1000.
- Format: Multiple-choice and scenario-based questions
- Duration: 100 minutes
- Pass mark: 700 out of 1000
- Valid for: 2 years. GitHub is moving to Microsoft's renewal process and extends by six months any certification that expires before that process is ready.
- Delivery: Pearson VUE, online proctored or at a test centre. No Microsoft Learn access during GitHub exams
- Prerequisites: Familiarity with CI/CD, GitHub repositories, and GitHub Packages recommended
Exam domains and weights
- Author and manage workflows: 20–25%
- Consume and troubleshoot workflows: 15–20%
- Author and maintain actions: 15–20%
- Manage GitHub Actions for the enterprise: 20–25%
- Secure and optimize automation: 10–15%
A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
10 GH-200 sample questions with answers: free to read, no account needed.
Common questions
How long is the GH-200 exam?
The GH-200 exam lasts 100 minutes.
What is the GH-200 passing score?
The pass mark is 700 out of 1000.
Is there a free GH-200 practice test?
Yes. A 20-question practice sampler is free with an account; Pro adds the full question bank and timed mock exams.
Source: Study guide for Exam GH-200: GitHub Actions (Microsoft Learn) (GitHub / Microsoft), checked 2026-10-03.
Who it is for
Intermediate level.
For engineers who write or look after GitHub Actions workflows and want to pass GH-200, from triggers and reusable workflows to runners, security and cost.
What you don't need yet:
- No GitHub account: every lab runs offline in your browser
- No runners or cloud account of your own
- No organisation or enterprise account for the admin topics
What helps:
- Reading YAML, and Git basics: commits, branches, pull requests
- Reading short scripts: labs run small Python and JavaScript files
No formal prerequisites. The courses under "Take first" cover what helps.
Take first:
- Continuous Integration & Continuous Delivery Pipelines — Intermediate
- Advanced Git Internals & Distributed Workflows — Beginner
Take next:
Learning paths:
Nobody needs to know everything before they start. Each course builds on the one before, so a learning path takes you there step by step.
What this exam proves, and what it doesn't
GitHub Actions is an exam of multiple-choice and scenario questions: passing shows you know how to write and run workflows. It doesn't test hands-on skill; our graded labs run workflows offline in your browser, not on GitHub.
Exam objectives this course teaches
GitHub Actions (GH-200)
- Author and manage workflows (20–25% of the exam): Configure workflow triggers and events: scheduled, manual, webhook, and repository events; scope, permissions, and events; workflow_dispatch inputs and workflow_call inputs/secrets mapping; Design and implement workflow structure: jobs, steps, conditional logic, job dependencies, workflow commands, environment variables, service containers, matrix strategies, YAML anchors/aliases, contexts and expressions, editor tooling; Manage workflow execution and outputs: caching and artifact management with retention policies, passing data between jobs and steps, job summaries (GITHUB_STEP_SUMMARY), workflow status badges and environment protections
- Consume and troubleshoot workflows (15–20% of the exam): Interpret workflow behavior and results: identify triggers and effects from configuration and logs; diagnose failed runs; interpret YAML anchors and matrix expansions; selectively rerun individual matrix jobs; Access workflow artifacts and logs: locate workflows, logs, and artifacts in the UI and via API; download and manage artifacts; Use and manage workflow templates: consume organization-level and reusable workflows; use starter workflows; differentiate starter workflows, reusable workflows, and composite actions; contrast disabling and deleting workflows
- Author and maintain actions (15–20% of the exam): Create and troubleshoot custom actions: implement action types (JavaScript, Docker, composite); understand immutable actions enforcement and version pinning; troubleshoot action execution and errors; Define action structure and metadata: specify required files, directory structure, and metadata; implement workflow commands within actions; Distribute and maintain actions: select distribution models (public, private, marketplace); publish actions to GitHub Marketplace; apply versioning and release strategies
- Manage GitHub Actions for the enterprise (20–25% of the exam): Distribute and govern actions and workflows: define and manage reusable components and templates; control access to actions and workflows within the enterprise; configure organizational use policies; Manage runners at scale: configure and monitor GitHub-hosted and self-hosted runners; apply IP allow lists and networking settings; manage runner groups and troubleshoot runner issues; identify preinstalled software and install additional tools at runtime; Manage encrypted secrets and variables: define and scope secrets and variables at organization, repository, and environment levels; access and use secrets/variables in workflows; manage via REST APIs
- Secure and optimize automation (10–15% of the exam): Implement security best practices: use environment protections and approval gates; identify trustworthy Marketplace actions; mitigate script injection; understand GITHUB_TOKEN lifecycle and configure permissions; use OIDC for cloud provider federation; pin third-party actions to full commit SHAs; enforce action usage policies; generate and verify artifact attestations/provenance; Optimize workflow performance and cost: configure caching and artifact retention for efficiency; apply retention policies via REST APIs; recommend strategies for scaling and optimizing workflows
Labs
78 labs, 64 of them graded: you write the code, it runs, and graded labs check the result. The outline lists each lesson's labs.
What is free
Start free: First module free with an account. Pro: Every course, lab, handbook, practice exam and certificate.
- Pro monthly — $29 a month. Every course, lab, handbook, practice exam and certificate
- Pro yearly — $249 a year. Every course, lab, handbook, practice exam and certificate
Course outline
Start Here
- The Workflow That Ran On A Stranger's Pull Request (2 labs): You can explain why a pull_request_target workflow that checks out a fork's code hands that code your secrets, read the trust each pull request trigger gets, and name the five GH-200 domains this course works through.
- How GH-200 Asks: Pacing, Weights And Stems (1 lab): You can plan your time across GH-200's hundred minutes, turn its published weight ranges into a revision budget, and read a YAML-heavy scenario stem for the one detail that decides it.
Author And Manage Workflows
- Triggers and the Event Model (5 labs): You can choose the right event and filters for a workflow, read the event payload and the github context that every run carries, keep fork code out of a privileged trigger, and stop two deploys racing with a concurrency group.
- Triggers In Depth: Filters, Schedules And Dispatch (3 labs): You can predict whether a push, tag, pull request, schedule or dispatch starts a workflow from its on: block alone, fix filters that silently skip the runs you need, and define workflow_dispatch inputs whose types, defaults and choices GitHub validates for you.
- Workflow Structure: Jobs, Env, Services, Commands And Anchors (4 labs): You can lay out jobs and steps with env and defaults at the right scope, give a job a service container it can actually reach, pass values to later steps with workflow commands and environment files, and reuse YAML with anchors and aliases while knowing GitHub does not support merge keys.
- Expressions, Contexts And The If That Is Always True (3 labs): You can evaluate GitHub Actions expressions the way the runner does, including loose equality, string outputs and && || values, write if conditions that use status functions correctly, and say which contexts each key can read.
- Matrices, Needs And Concurrency: The Shape Of A Run (4 labs): You can expand a matrix with include and exclude exactly as GitHub does, predict which jobs fail-fast cancels and which needs skips, and choose a concurrency group and cancel-in-progress setting that stops runs racing without losing the one you need.
- Reusable Workflows: Inputs, Secrets And Outputs Across A Call (3 labs): You can write a reusable workflow's workflow_call contract, call it with the right inputs and secrets (or secrets: inherit), read its outputs from needs, and predict what the called workflow can and cannot see.
- Outputs, Artifacts, Caches And Job Summaries (3 labs): You can move a value from a step to a later job through declared job outputs, choose between job outputs, artifacts and caches, predict which cache entry a run restores and whether it may save one, and set retention, job summaries and status badges.
Consume And Troubleshoot Workflows
- Why It Ran, Why It Did Not: Reading Runs, Jobs And Checks (3 labs): You can explain from configuration, workflow state and the run list why a workflow did or did not run, account for every job conclusion in a run including matrix legs and aliased configuration, and find required checks that will never report.
- Failed Runs: Debug Logging And Re-Running The Right Jobs (2 labs): You can diagnose a failed run from its annotations and logs, switch on step and runner debug logging, and choose between re-running all jobs, failed jobs or one job, knowing what each re-run repeats and what it keeps.
- Logs And Artifacts Without The Browser: REST And The gh CLI (2 labs): You can find runs, jobs, logs and artifacts in the Actions UI, through the REST API and with gh run, download them before their links expire, and manage artifact retention and deletion.
- Workflow Templates: Sharing Workflows Across An Organization (3 labs): You can publish organization workflow templates with their metadata, predict which repositories are offered each one, consume a template, tell templates, reusable workflows and composite actions apart, and choose between disabling and deleting a workflow.
Author And Maintain Actions
- Three Kinds Of Action: JavaScript, Docker Container Or Composite (2 labs): You can choose between a JavaScript, Docker container and composite action for a need, knowing where each runs, how fast it starts, what files it ships and how its inputs reach the code.
- action.yml: Inputs, Outputs, Runs And Branding (3 labs): You can write an action's metadata file with its required keys, inputs, outputs, runs section and branding, place the action's files where a workflow can use them, and catch metadata mistakes with actionlint before a run does.
- Building And Debugging A JavaScript Action (4 labs): You can write a JavaScript action that reads inputs, sets outputs, raises annotations, masks secrets and fails with the right exit code, and debug it from its log with step debug logging.
- Composite And Docker Actions: Troubleshooting And Immutable Releases (3 labs): You can build and troubleshoot composite and Docker container actions, read their typical failures from the log, and explain what immutable releases lock and how they combine with movable major-version tags.
- Distributing And Versioning Actions: Tags, SHAs And Marketplace (2 labs): You can choose how to share an action (public, internal or private repository, or Marketplace), release it with semantic version tags and a movable major tag, ship a breaking change as a new major version, and predict what each caller's ref resolves to.
Manage GitHub Actions For The Enterprise
- Governing Actions: Allow Lists, SHA Pinning And Rulesets (2 labs): You can predict whether an organization's allowed-actions policy permits a given uses reference, configure GitHub-owned, verified and pattern rules with blocks and SHA pinning, and enforce shared workflows and fork-run approval across repositories.
- GitHub-Hosted And Larger Runners: Specs, Software And Networks (2 labs): You can predict the machine a runs-on label gets, choose larger runners and runner groups for heavy or networked jobs, install missing tools at run time, and decide how GitHub-hosted runners reach a firewalled resource.
- Self-Hosted Runners At Scale: Labels, Groups And ARC (2 labs): You can route jobs to self-hosted runners with labels and groups, restrict groups by repository and workflow, keep self-hosted runners away from public repositories, choose ephemeral and autoscaled runners with Actions Runner Controller, and troubleshoot jobs that never start.
- Secrets And Variables By Scope: Precedence, Access And The REST API (2 labs): You can define secrets and variables at organization, repository and environment level, predict which value a job receives, control which repositories an organization secret reaches, use them safely in workflows, and manage them through the REST API.
- Usage, Billing And The Audit Log (2 labs): You can read an Actions usage report, work out which minutes and storage are billed, control spending, and use the audit log to find who changed Actions settings, secrets and runners.
Secure And Optimize Automation
- GITHUB_TOKEN: Least Privilege, Job By Job (3 labs): You can predict the permissions a job's GITHUB_TOKEN ends up with from the repository default and the permissions keys, grant each job only the scopes its calls need, and explain the token's lifetime, why its pushes start no new runs, and when a GitHub App token or a personal access token is the better choice.
- Environments: Reviewers, Wait Timers And Deployment Rules (2 labs): You can protect a deployment with an environment's required reviewers, self-review prevention, wait timer and deployment branch and tag rules, predict whether a job proceeds, waits or is rejected, and say when its environment secrets become available.
- Script Injection: When An Issue Title Becomes Code (2 labs): You can spot untrusted ${{ }} values written into run scripts, show why they execute, fix them by passing values through environment variables, and apply the controls GitHub recommends for pull_request_target and other privileged triggers.
- OIDC: Cloud Access Without Stored Keys (3 labs): You can configure a job to request a GitHub OIDC token, read its issuer, audience and subject claims, write a cloud trust condition that admits only the job you mean, and explain why a forged or expired token is refused.
- Supply Chain: Pinning, Trusted Actions And Attestations (2 labs): You can find actions referenced by moving tags or branches, explain why only a full commit SHA is immutable, choose trustworthy Marketplace actions and the organization policies that enforce SHA pinning, and check that an artifact matches its build provenance attestation.
- Faster And Cheaper: Where The Minutes Go (2 labs): You can work out what a workflow costs from billed minutes and runner rates, find the jobs that dominate the bill, and choose the changes that cut time and cost most: path filters, cancel-in-progress, caching, matrix trimming, runner choice, timeouts and retention.
Mock And Review
- YAML-Reading Sprint: What Happens When This Runs? (1 lab): You can answer what-happens-when-this-runs questions quickly: whether a trigger fires, how a matrix expands, which jobs run or skip, and which conditions, outputs, permissions and policies change the result.
- Full Mock And Review: Where Your Points Go (1 lab): You can sit a timed mock weighted like GH-200, turn the result into points lost per domain using the published weight ranges, and choose what to revise first in the days before the exam.