All posts
Written by Sujith Quintelier Aug 8, 2025

🐙 GitHub Certification Journey: Part 1 - GitHub Foundations (GH-900)

Master GitHub Foundations (GH-900) certification with comprehensive coverage of Git basics, collaboration workflows, and security fundamentals.
Aug 8, 2025

Welcome to the GitHub Certification Journey! This comprehensive guide covers everything you need to master the GitHub Foundations (GH-900) certification. Whether you’re new to Git and GitHub or looking to validate your foundational knowledge, this post provides complete coverage of all exam domains with practical examples and hands-on exercises.

Why GitHub Foundations Certification Matters

The GitHub Foundations certification validates your understanding of Git version control and GitHub collaboration fundamentals. As the entry point to GitHub’s certification pathway, it demonstrates your ability to:

  • Use Git for version control effectively
  • Collaborate on projects using GitHub workflows
  • Manage repositories and understand GitHub’s ecosystem
  • Apply basic DevOps principles with GitHub tools

Career Impact: This certification opens doors to development, DevOps, and technical roles where Git and GitHub knowledge is essential. It’s particularly valuable for developers, project managers, and anyone working in modern software development environments.

Exam Overview

Exam Details

  • Duration: 100 minutes
  • Questions: Approximately 75 questions
  • Question Types: Multiple choice and scenario-based questions
  • Passing Score: 700 out of 1000 points
  • Cost: £99 (may vary by region)
  • Delivery: Online proctored or at testing centres
  • Prerequisites: None (foundational level)

What to Expect

The exam tests practical knowledge rather than memorisation. You’ll encounter scenarios about:

  • Choosing appropriate Git commands for specific situations
  • Understanding GitHub workflow implications
  • Solving collaboration challenges
  • Configuring repository settings appropriately

Skills Measured: Complete Domain Breakdown

Let’s dive deep into each domain, covering every skill you need for exam success.

Domain 1: Introduction to Git and GitHub (22%)

This is the largest domain, focusing on fundamental Git concepts and GitHub navigation.

Understanding Git Basics

What Git Is

Git is a distributed version control system that tracks changes in files and coordinates work among multiple people. Key concepts:

  • Repository (Repo): A directory containing your project files and Git metadata
  • Commit: A snapshot of your project at a specific point in time
  • Branch: A parallel version of your repository
  • Merge: Combining changes from different branches

Basic Git Workflow

The fundamental Git workflow follows this pattern:

  1. Modify files in your working directory
  2. Stage changes using git add
  3. Commit staged changes using git commit
  4. Push commits to remote repository using git push
# Example workflow
git add filename.txt        # Stage specific file
git add .                   # Stage all changes
git commit -m "Add new feature"  # Commit with message
git push origin main        # Push to remote repository

Local vs Remote Repositories

  • Local Repository: Exists on your computer, contains complete project history
  • Remote Repository: Hosted on GitHub (or other platforms), enables collaboration
  • Clone: Creates local copy of remote repository
  • Fork: Creates your own copy of someone else’s repository

Essential Git Commands

Repository Initialisation and Cloning

# Initialise new repository
git init

# Clone existing repository
git clone https://github.com/username/repository.git

# Clone to specific directory
git clone https://github.com/username/repository.git my-project

Basic File Operations

# Check repository status
git status

# Add files to staging area
git add filename.txt        # Specific file
git add *.js               # All JavaScript files
git add .                  # All changes

# Commit changes
git commit -m "Descriptive commit message"
git commit -am "Add and commit in one step"  # For tracked files

# View commit history
git log
git log --oneline          # Compact format
git log --graph            # Visual representation

Remote Repository Operations

# Add remote repository
git remote add origin https://github.com/username/repository.git

# View remote repositories
git remote -v

# Push changes to remote
git push origin main       # Push to main branch
git push -u origin main    # Set upstream tracking

# Pull changes from remote
git pull origin main       # Fetch and merge
git fetch origin          # Fetch without merging

Branching and Merging

# Create new branch
git branch feature-branch
git checkout -b feature-branch  # Create and switch

# Switch branches
git checkout main
git switch feature-branch      # Modern alternative

# List branches
git branch                 # Local branches
git branch -r             # Remote branches
git branch -a             # All branches

# Merge branches
git checkout main
git merge feature-branch

# Delete branch
git branch -d feature-branch   # Delete merged branch
git branch -D feature-branch   # Force delete

Account Creation and Setup Understanding GitHub account types and initial setup:

  • Personal Account: Free tier includes unlimited public/private repositories
  • Organization Account: For teams and businesses
  • GitHub Enterprise: Advanced features for large organisations

Essential Profile Setup:

# Example README.md for profile
## Hi there 👋

I'm a developer passionate about:
- Cloud technologies
- Open source contributions
- DevOps practices

### Current Projects
- [Project Name](link) - Brief description

Repository Management Key repository concepts for the exam:

  • Repository Types: Public (visible to everyone) vs Private (restricted access)
  • Repository Structure: README.md, LICENSE, .gitignore, code organisation
  • Repository Settings: Access permissions, branch protection, webhooks

GitHub Interface Navigation Essential interface elements:

  • Repository tabs: Code, Issues, Pull requests, Actions, Projects, Wiki, Settings
  • File browser: Navigate code, view history, edit files online
  • Search functionality: Code search, repository search, user search

Issues and Pull Requests Fundamentals

Issues are used for:

  • Bug reports and feature requests
  • Task tracking and project planning
  • Discussions and questions

Pull Requests enable:

  • Code review processes
  • Collaborative development
  • Merge approval workflows

Domain 2: Working with GitHub Repositories (8%)

This domain focuses on practical repository management skills.

Managing Repository Settings

Repository Configuration Essential settings you need to understand:

# .github/dependabot.yml example
version: 2
updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"

Access and Permissions Repository permission levels:

  • Read: View and clone repository
  • Triage: Manage issues and pull requests
  • Write: Push changes and manage some settings
  • Maintain: Manage repository without access to sensitive actions
  • Admin: Full repository access

Repository Templates Creating reusable repository structures:

  • Template repositories for consistent project setup
  • Including standard files: README, LICENSE, .gitignore
  • Automated repository creation from templates

Working with Files

Adding and Editing Files Multiple methods for file management:

Via GitHub Web Interface:

  1. Navigate to repository
  2. Click “Add file” or “Create new file”
  3. Edit content using built-in editor
  4. Commit changes directly

Via Git Commands:

# Create new file
touch newfile.txt
echo "Content" > newfile.txt

# Edit existing file (using editor)
nano README.md
vim config.json

# Stage and commit
git add newfile.txt
git commit -m "Add new configuration file"

File Versioning Understanding file history and versioning:

  • Blame view: See who changed each line and when
  • History view: Complete change history for files
  • Diff view: Compare different versions

GitHub Desktop Integration Key features of GitHub Desktop:

  • Visual diff representation
  • Simplified branching and merging
  • Sync with GitHub repositories
  • Conflict resolution interface

Domain 3: Collaboration Features (30%)

This is the most substantial domain, covering GitHub’s collaborative capabilities.

GitHub Collaboration Workflows

Forking Repositories The fork workflow is essential for open source contribution:

  1. Fork the original repository to your account
  2. Clone your fork locally
  3. Create a feature branch
  4. Make changes and commit
  5. Push to your fork
  6. Create pull request to original repository
# Complete fork workflow example
git clone https://github.com/yourusername/forked-repo.git
cd forked-repo
git checkout -b feature-improvement
# Make changes
git add .
git commit -m "Implement feature improvement"
git push origin feature-improvement
# Create PR via GitHub interface

Pull Request Lifecycle

Creating Pull Requests:

  • Clear title and description
  • Reference related issues
  • Include testing information
  • Request specific reviewers

Pull Request Template Example:

## Description
Brief description of changes

## Type of Change
- [ ] Bug fix
- [ ] New feature
- [ ] Breaking change
- [ ] Documentation update

## Testing
- [ ] Tests pass locally
- [ ] Added new tests
- [ ] Manual testing completed

## Checklist
- [ ] Code follows style guidelines
- [ ] Self-review completed
- [ ] Documentation updated

Managing Pull Requests:

  • Draft Pull Requests: Work-in-progress marker
  • Review Requests: Assign specific reviewers
  • Status Checks: Automated testing integration
  • Merge Options: Merge commit, squash and merge, rebase and merge

Reviewing Pull Requests:

  • Line-by-line comments: Specific feedback on code changes
  • General comments: Overall feedback and suggestions
  • Review states: Approve, request changes, or comment only
  • Suggested changes: Propose specific code modifications

Merging Pull Requests:

  • Merge Commit: Preserves complete history
  • Squash and Merge: Combines commits into single commit
  • Rebase and Merge: Replays commits without merge commit

GitHub Actions for CI/CD

Basic GitHub Actions Concepts GitHub Actions automates software workflows:

  • Workflow: Automated process triggered by events
  • Job: Set of steps executed on same runner
  • Step: Individual task within job
  • Action: Reusable unit of code

Simple Workflow Example:

# .github/workflows/ci.yml
name: Continuous Integration

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Set up Node.js
      uses: actions/setup-node@v3
      with:
        node-version: '18'
        
    - name: Install dependencies
      run: npm install
      
    - name: Run tests
      run: npm test

Common Workflow Triggers:

  • push: Code pushed to repository
  • pull_request: Pull request created or updated
  • schedule: Time-based triggers
  • workflow_dispatch: Manual trigger

Project Management with GitHub

Issues Management

Creating Effective Issues:

# Bug Report Template
## Bug Description
Clear description of the bug

## Steps to Reproduce
1. Go to...
2. Click on...
3. See error

## Expected Behavior
What should happen

## Actual Behavior
What actually happened

## Environment
- OS: [e.g. Windows 10]
- Browser: [e.g. Chrome 91]
- Version: [e.g. 1.0.0]

Issue Labels Standard label categories:

  • Type: bug, enhancement, documentation
  • Priority: high, medium, low
  • Status: in progress, needs review, blocked
  • Area: frontend, backend, testing

Milestones Organising issues and PRs by:

  • Version releases: v1.0.0, v1.1.0
  • Sprint goals: Sprint 1, Sprint 2
  • Feature sets: User authentication, Payment system

GitHub Projects

Project Boards:

  • Basic Kanban: To Do, In Progress, Done
  • Advanced Workflows: Multiple swimlanes and automation
  • Custom Fields: Priority, assignee, labels integration

Project Automation:

# Example project automation
- Move issues to "In Progress" when assigned
- Move PRs to "Review" when opened
- Move items to "Done" when closed

Tracking Progress:

  • Burndown charts: Visual progress representation
  • Velocity tracking: Team performance metrics
  • Cross-repository projects: Multi-repo coordination

Domain 4: Modern Development (13%)

This domain covers DevOps practices and code review processes.

Implementing DevOps Practices

DevOps Principles in GitHub Core principles supported by GitHub:

  • Collaboration: Issues, PRs, and team features
  • Automation: GitHub Actions and workflow automation
  • Continuous Integration: Automated testing and building
  • Continuous Delivery: Automated deployment pipelines
  • Monitoring: Insights and analytics

CI/CD Pipeline Implementation

Continuous Integration Example:

name: CI Pipeline

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3
    - name: Lint code
      run: |
        npm install
        npm run lint

  test:
    runs-on: ubuntu-latest
    needs: lint
    steps:
    - uses: actions/checkout@v3
    - name: Run tests
      run: |
        npm install
        npm test
        
  build:
    runs-on: ubuntu-latest
    needs: [lint, test]
    steps:
    - uses: actions/checkout@v3
    - name: Build application
      run: |
        npm install
        npm run build

Continuous Deployment Example:

name: Deploy to Production

on:
  push:
    branches: [ main ]

jobs:
  deploy:
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    
    steps:
    - uses: actions/checkout@v3
    
    - name: Deploy to Azure
      uses: azure/webapps-deploy@v2
      with:
        app-name: 'my-app'
        publish-profile: ${{ secrets.AZURE_WEBAPP_PUBLISH_PROFILE }}

GitHub Actions Automation Common automation patterns:

  • Automated testing: Run test suites on every commit
  • Code quality checks: ESLint, SonarQube integration
  • Security scanning: Dependency vulnerability checks
  • Documentation generation: Auto-update docs from code

Code Review Best Practices

Effective Code Reviews

Review Checklist:

  • Functionality: Does the code do what it’s supposed to do?
  • Performance: Are there any performance concerns?
  • Security: Are there security vulnerabilities?
  • Maintainability: Is the code readable and well-documented?
  • Testing: Are there adequate tests?

Review Tools in GitHub:

  • Diff view: Side-by-side or unified diff options
  • Comment threads: Discussions on specific lines
  • Review summary: Overall approval or change requests
  • Suggested changes: Propose specific code modifications

Code Review Workflow:

# Reviewer workflow
git fetch origin
git checkout pr-branch-name
git pull origin pr-branch-name
# Review changes locally
# Test functionality
# Leave review comments via GitHub

Review Response Best Practices:

  • Be constructive: Focus on code improvement
  • Be specific: Point out exact issues and solutions
  • Be timely: Respond to reviews promptly
  • Be open: Accept feedback gracefully

Domain 5: Project Management (7%)

Focus on GitHub’s project management capabilities.

GitHub Projects Deep Dive

Project Types Understanding different project approaches:

  • Repository Projects: Scoped to single repository
  • Organization Projects: Cross-repository coordination
  • User Projects: Personal project management

Project Views Different ways to visualise work:

  • Table View: Spreadsheet-like data organisation
  • Board View: Kanban-style workflow boards
  • Roadmap View: Timeline-based planning

Custom Fields Enhancing projects with metadata:

# Example custom fields
- Priority: High, Medium, Low
- Story Points: 1, 2, 3, 5, 8
- Component: Frontend, Backend, Database
- Reviewer: Team member assignments

Project Automation Automated workflow examples:

# Move items based on status
- When PR is opened → Move to "In Review"
- When issue is closed → Move to "Done"
- When issue is labeled "bug" → Set priority to "High"

Integration with Issues and Pull Requests

Linking Work Items Connecting projects to development work:

# In issue or PR description
Closes #123
Fixes #456
Resolves #789

# Multiple issues
Closes #123, #456, #789

Project Board Integration:

  • Automatic addition: New issues automatically added
  • Status synchronisation: Board status reflects issue state
  • Cross-repository tracking: Issues from multiple repos

Progress Tracking:

  • Completion percentage: Visual progress indicators
  • Milestone integration: Align projects with release milestones
  • Reporting: Progress reports and team analytics

Domain 6: Privacy, Security, and Administration (10%)

Critical security and administrative concepts.

Repository Security

Branch Protection Rules Essential protections for important branches:

{
  "required_status_checks": {
    "strict": true,
    "contexts": ["ci/test", "ci/lint"]
  },
  "enforce_admins": true,
  "required_pull_request_reviews": {
    "required_approving_review_count": 2,
    "dismiss_stale_reviews": true,
    "require_code_owner_reviews": true
  },
  "restrictions": null
}

Key Protection Features:

  • Require pull request reviews: Mandatory code review
  • Require status checks: CI must pass before merge
  • Require branches to be up to date: Prevent stale merges
  • Include administrators: Apply rules to all users

Dependabot Security Automated dependency management:

# .github/dependabot.yml
version: 2
updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "daily"
    open-pull-requests-limit: 10
    reviewers:
      - "security-team"
    assignees:
      - "lead-developer"

Security Features:

  • Vulnerability alerts: Automatic security notifications
  • Security updates: Automated dependency updates
  • Security advisories: Community vulnerability reports

Access Control and Permissions

Repository Permissions:

  • Public repositories: Visible to everyone, configurable contributions
  • Private repositories: Restricted access, team-based permissions
  • Internal repositories: Visible to organization members only

Permission Levels:

  • Read: Clone and fetch, create issues and comments
  • Triage: Manage issues and pull requests without write access
  • Write: Push to repository, manage issues and PRs
  • Maintain: Manage repository settings except sensitive actions
  • Admin: Full repository access including deletion

GitHub Organizations

Organization Structure Understanding organizational hierarchy:

  • Organization: Top-level container for repositories and teams
  • Teams: Groups of users with specific permissions
  • Repositories: Individual project containers
  • Members: Users with organization access

Creating and Managing Organizations:

# Organization setup considerations
- Organization name and description
- Billing and plan selection
- Member invitation and permissions
- Team structure planning
- Repository organization strategy

Organization Security Settings:

  • Two-factor authentication: Require 2FA for all members
  • SSH key management: Organization-wide SSH policies
  • OAuth app restrictions: Control third-party app access
  • SAML SSO: Enterprise identity integration

Team Management:

  • Team creation: Organize members by project or function
  • Team permissions: Assign repository access levels
  • Team mentions: Use @team-name for group communication
  • Team discussions: Private team communication channels

Domain 7: Benefits of the GitHub Community (10%)

Understanding GitHub’s community aspects and contribution culture.

Open Source Participation

Contributing to Open Source Steps for meaningful contribution:

  1. Find projects: Use GitHub search and trending repositories
  2. Understand contribution guidelines: Read CONTRIBUTING.md
  3. Start small: Fix typos, improve documentation
  4. Follow project conventions: Code style, commit messages
  5. Engage with maintainers: Ask questions, seek guidance

Contribution Types:

  • Code contributions: Bug fixes, feature implementations
  • Documentation: README improvements, API documentation
  • Testing: Test case additions, bug reports
  • Translation: Localisation and internationalisation
  • Design: UI/UX improvements, graphics

Good First Issue Practice:

# Example good first issue
## Title: Add dark mode toggle to settings page

## Description
Users have requested a dark mode option. We need to add a toggle 
switch to the settings page that switches between light and dark themes.

## Technical Details
- Add toggle component to settings.js
- Update CSS with dark theme variables
- Store preference in localStorage

## Acceptance Criteria
- [ ] Toggle appears in settings
- [ ] Theme switches immediately
- [ ] Preference persists across sessions

Labels: good first issue, enhancement, frontend

GitHub Discussions

Community Engagement Using Discussions for community building:

  • Q&A: Community support and knowledge sharing
  • Ideas: Feature requests and project direction
  • General: Open-ended community conversations
  • Show and tell: Community showcases and demos

Discussion Best Practices:

  • Clear titles: Make discussions discoverable
  • Detailed descriptions: Provide context and background
  • Engage actively: Respond to community input
  • Moderate effectively: Maintain productive conversations

Community Guidelines:

# Example community guidelines
## Our Standards
- Be respectful and inclusive
- Stay on topic and relevant
- Help others learn and grow
- Follow the code of conduct

## Reporting Issues
- Use issue templates
- Provide reproducible examples
- Search existing issues first
- Be patient with responses

Community Contribution Culture

Open Source Etiquette Professional contribution practices:

  • Read documentation: Understand project goals and conventions
  • Start with issues: Don’t submit unsolicited major changes
  • Follow coding standards: Match existing code style
  • Write clear commit messages: Explain what and why
  • Be patient: Maintainers are often volunteers

Building Reputation:

  • Consistent contributions: Regular, quality contributions
  • Helpful reviews: Constructive feedback on others’ work
  • Documentation improvements: Often overlooked but valuable
  • Community support: Helping other contributors

Maintainer Perspective: Understanding the maintainer’s role:

  • Project vision: Maintaining project direction and quality
  • Community management: Fostering positive contributor environment
  • Release management: Planning and executing releases
  • Issue triage: Prioritising and categorising community input

Hands-On Practice Exercises

To solidify your understanding, complete these practical exercises:

Exercise 1: Repository Setup and Basic Git Operations

# Create a new repository
git init my-practice-repo
cd my-practice-repo

# Create initial files
echo "# My Practice Repository" > README.md
echo "node_modules/" > .gitignore
echo "*.log" >> .gitignore

# Stage and commit
git add .
git commit -m "Initial commit with README and gitignore"

# Create and work with branches
git checkout -b feature-branch
echo "console.log('Hello, GitHub!');" > app.js
git add app.js
git commit -m "Add basic JavaScript file"

# Switch back to main and merge
git checkout main
git merge feature-branch
git branch -d feature-branch

Exercise 2: GitHub Workflow Practice

  1. Create a GitHub repository with proper README, LICENSE, and .gitignore
  2. Set up branch protection for the main branch
  3. Create an issue using a template
  4. Create a pull request with proper description and linking to the issue
  5. Review and merge the pull request using different merge strategies

Exercise 3: GitHub Actions Setup

Create a simple CI workflow:

# .github/workflows/practice.yml
name: Practice Workflow

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  practice:
    runs-on: ubuntu-latest
    
    steps:
    - name: Checkout code
      uses: actions/checkout@v3
      
    - name: Print repository info
      run: |
        echo "Repository: ${{ github.repository }}"
        echo "Branch: ${{ github.ref }}"
        echo "Event: ${{ github.event_name }}"
        
    - name: List files
      run: ls -la

Study Strategy and Timeline

4-Week Study Plan

Week 1: Git Fundamentals

  • Day 1-2: Git concepts and basic commands
  • Day 3-4: Branching and merging
  • Day 5-7: Practice exercises and command practice

Week 2: GitHub Features

  • Day 1-2: Repository management and navigation
  • Day 3-4: Issues and pull requests
  • Day 5-7: Collaboration workflows and practice

Week 3: Advanced Features

  • Day 1-2: GitHub Actions basics
  • Day 3-4: Project management features
  • Day 5-7: Security and administration

Week 4: Integration and Review

  • Day 1-2: Community features and open source
  • Day 3-4: Practice exams and weak area review
  • Day 5-7: Final review and exam preparation

Study Resources

Official GitHub Resources:

Practice Platforms:

Community Resources:

Exam Preparation Tips

Effective Study Techniques

Active Learning:

  • Practice regularly: Use Git and GitHub daily
  • Teach others: Explain concepts to reinforce understanding
  • Build projects: Apply skills in real scenarios
  • Join communities: Engage with other learners

Mock Exams and Practice:

  • Scenario-based practice: Work through realistic situations
  • Time management: Practice under exam time constraints
  • Weak area focus: Identify and strengthen weak points
  • Official practice tests: Use Microsoft Learn practice assessments

Common Exam Pitfalls

Areas of Confusion:

  • Git vs GitHub: Understanding the distinction and relationship
  • Merge strategies: When to use different merge options
  • Permission levels: Understanding granular access controls
  • Workflow triggers: GitHub Actions trigger conditions

Time Management:

  • Read carefully: Understand what each question is asking
  • Eliminate options: Rule out obviously incorrect answers
  • Flag and return: Don’t spend too much time on difficult questions
  • Review answers: Use remaining time to review flagged questions

Career Benefits and Next Steps

Job Opportunities

Roles Enhanced by GitHub Foundations:

  • Software Developer: Version control and collaboration skills
  • DevOps Engineer: Understanding of CI/CD and automation
  • Project Manager: Technical project management capabilities
  • Technical Writer: Documentation and collaboration workflows

Salary Impact: According to industry surveys, professionals with Git and GitHub skills command 15-25% higher salaries than those without version control experience.

Certification Pathway

Next Recommended Certifications:

  1. For Developers: GitHub Actions (GH-200) or GitHub Copilot (GH-300)
  2. For DevOps Engineers: GitHub Actions (GH-200) then GitHub Administration (GH-100)
  3. For Administrators: GitHub Administration (GH-100)
  4. For Security Professionals: GitHub Administration (GH-100) then GitHub Advanced Security (GH-500)

Continuing Education

Stay Current:

  • GitHub Blog: Follow product updates and new features
  • GitHub Universe: Annual conference with latest announcements
  • Release Notes: Stay updated with new GitHub capabilities
  • Community Discussions: Engage with other professionals

Conclusion

The GitHub Foundations (GH-900) certification validates essential skills for modern software development and collaboration. By mastering Git version control, GitHub workflows, project management, and community participation, you’ll build a strong foundation for advanced GitHub certifications and enhance your career prospects.

Key Takeaways:

  • Git fundamentals are essential for all development work
  • GitHub collaboration enables effective team development
  • Project management features streamline development workflows
  • Security practices protect code and communities
  • Community engagement accelerates learning and career growth

Next Steps:

  1. Complete hands-on exercises to reinforce learning
  2. Practice with real repositories to gain experience
  3. Schedule your exam when you feel confident
  4. Plan your next certification based on career goals

Remember: The exam tests practical application, not memorisation. Focus on understanding workflows and real-world scenarios rather than memorising commands. Good luck with your GitHub Foundations certification journey!


Ready to take the next step in your GitHub certification journey? Check out our upcoming posts covering GitHub Administration (GH-100) and GitHub Actions (GH-200) certifications.

Sponsored by GitAds
comments powered by Disqus