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

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:
- Modify files in your working directory
- Stage changes using
git add
- Commit staged changes using
git commit
- 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
Navigating GitHub
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:
- Navigate to repository
- Click “Add file” or “Create new file”
- Edit content using built-in editor
- 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:
- Fork the original repository to your account
- Clone your fork locally
- Create a feature branch
- Make changes and commit
- Push to your fork
- 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 repositorypull_request
: Pull request created or updatedschedule
: Time-based triggersworkflow_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:
- Find projects: Use GitHub search and trending repositories
- Understand contribution guidelines: Read CONTRIBUTING.md
- Start small: Fix typos, improve documentation
- Follow project conventions: Code style, commit messages
- 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
- Create a GitHub repository with proper README, LICENSE, and .gitignore
- Set up branch protection for the main branch
- Create an issue using a template
- Create a pull request with proper description and linking to the issue
- 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:
- GitHub Skills - Interactive learning paths
- GitHub Docs - Comprehensive documentation
- Git Handbook - Git fundamentals
Practice Platforms:
- GitHub Learning Lab - Hands-on courses
- Git Immersion - Git tutorial walkthrough
- Learn Git Branching - Interactive Git visualization
Community Resources:
- GitHub Community Forum - Community support
- GitHub YouTube Channel - Official tutorials
- Git Documentation - Official Git documentation
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:
- For Developers: GitHub Actions (GH-200) or GitHub Copilot (GH-300)
- For DevOps Engineers: GitHub Actions (GH-200) then GitHub Administration (GH-100)
- For Administrators: GitHub Administration (GH-100)
- 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:
- Complete hands-on exercises to reinforce learning
- Practice with real repositories to gain experience
- Schedule your exam when you feel confident
- 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.