GitHub Foundations Certification

21 min readDec 10, 2025

GitHub has become an essential tool in modern software development workflows. The GitHub Foundations Certification is designed to validate fundamental knowledge and awareness of the GitHub ecosystem.

I took this exam and successfully passed it, and during my preparation process, I created detailed notes to support my learning. I am sharing these notes to help others who are preparing for the GitHub Foundations exam. Most of the content is based on the Microsoft GitHub Foundations training.

GitHub Foundations - Certifications

This exam is targeted towards GitHub users who want to validate their understanding of the foundational topics…

learn.microsoft.com

To keep the material structured and easy to follow, I divided my notes into two parts.
In this article, the topics covered are structured as follows:

Module 1: Introduction to Git
Module 2: Introduction to GitHub
Module 3: Introduction to GitHub Products
Module 4: Configure Code Scanning on GitHub
Module 5: GitHub Copilot
Module 6: Code with GitHub Codespaces
Module 7: Manage Your Work with GitHub Projects
Module 8: Communicate Effectively on GitHub Using Markdown

Module 1: Introduction to Git

Version control is a fundamental concept in modern software development, enabling teams to track, manage, and organize changes to files over time. At its core, a version control system (VCS) records every modification made to a set of files, allowing developers to review history, revert to previous states, and collaborate safely on shared codebases.

By using version control, developers can confidently experiment with new features or fixes without risking the stability of the main project.

What Does Version Control Provide?

Version control systems offer several key benefits:

Change Tracking: Monitor what changes were made, when they occurred, and who made them.
Collaboration: Enable multiple contributors to work on the same project simultaneously without conflicts.
Branching and Merging: Support independent lines of development — such as feature work or bug fixes — that can later be merged back into the main codebase.
Tags and Releases: Allow specific commits to be labeled as milestones, such as official releases or stable versions.

Git: The Most Widely Used Version Control System

Among the available version control tools, Git stands out as the most widely adopted. Created by Linus Torvalds, the creator of Linux, Git is fast, open-source, and highly scalable. It uses a distributed architecture, meaning every contributor has a complete copy of the project’s history on their local machine.

This decentralized model increases reliability, reduces dependency on a central server, and enables developers to work offline.

Common Git Terminology

To better understand Git, it is helpful to be familiar with the following core concepts:

Repository (repo): A directory that contains the project files along with their full version history.
Commit: A snapshot that records changes made to the repository.
Branch: A separate line of development used for new features, experiments, or fixes.
Push / Pull: Operations used to send changes to or retrieve updates from a remote repository (such as GitHub).
Merge: The process of combining changes from different branches into a single branch.

Git Command Line and GitHub

Although graphical tools like GitHub Desktop are available, the command line interface (CLI) provides the most complete access to Git’s capabilities. Mastering the Git CLI allows developers to work more efficiently and with greater control.

GitHub, a cloud-based platform built on top of Git, enhances collaboration by providing features such as pull requests, issues, and project boards. While Git is responsible for version control, GitHub serves as a centralized space to host repositories, manage teamwork, and streamline development workflows.

Module 2: Introduction to GitHub

GitHub is a cloud-based platform built on top of Git, the distributed version control system. It brings version control, collaboration, and project management together in a single environment, enabling developers to track changes, work efficiently as a team, and manage software projects at scale.

By extending Git with a web-based interface and powerful collaboration tools, GitHub has become a central hub for both individual developers and large engineering teams.

The Foundation of GitHub: Git

Before fully understanding GitHub, it is essential to understand Git itself. Git is a distributed version control system that allows developers to track changes, manage revisions, and collaborate over time. GitHub enhances Git by adding usability, visibility, and automation — making workflows more accessible and productive for teams of all sizes.

Core Features of GitHub

Collaboration

GitHub is designed to make collaboration straightforward and efficient. Through repositories, issues, pull requests, and discussions, teams can review code, track tasks, and communicate effectively.

In addition, GitHub offers AI-powered tools such as GitHub Copilot, which assists developers while writing code and helps improve productivity throughout the development lifecycle.

Productivity and Automation

GitHub integrates CI/CD (Continuous Integration and Continuous Delivery) pipelines directly into the platform. These automation features reduce repetitive manual tasks, accelerate development cycles, and allow developers to focus on building and improving software.

Security

Security is embedded into GitHub’s development workflow. Tools such as CodeQL, Dependabot, and secret scanning help identify vulnerabilities early in the development process. These built-in security features are trusted by organizations of all sizes, including Microsoft.

Scale and Community

With over 100 million developers and hundreds of millions of repositories, GitHub hosts one of the largest developer communities in the world. This scale drives innovation, knowledge sharing, and continuous improvement across the platform.

AI Integration

GitHub leverages generative AI to enhance the developer experience. Tools like GitHub Copilot, AI-assisted pull requests, and intelligent issue management help streamline collaboration and improve code quality.

GitHub Repositories: The Center of Your Project

A repository (repo) is where a project’s files and full change history are stored. Repositories allow developers to manage code, track revisions, and collaborate with others efficiently.

Key repository actions include:

Creating a repository: Set up a project with a name, description, and visibility (public or private).
Cloning a repository: Create a local copy of a repository to work offline and sync changes later.
Adding and committing files: Upload or modify files and commit changes to track progress over time.

Additional GitHub Features

GitHub provides several supporting tools that enhance development workflows:

Gists: Lightweight repositories ideal for sharing small code snippets or notes.
Wikis: Built-in documentation spaces for guides, design documents, and references.
GitHub Pages: A feature that allows hosting static websites directly from a repository.

GitHub Enterprise: Tools for Teams and Organizations

For larger teams and organizations, GitHub Enterprise offers enhanced capabilities, including:

AI-powered productivity tools such as Copilot and Copilot Chat
Advanced collaboration features that improve workflow efficiency
Enterprise-level security with automated vulnerability scanning and dependency management

Understanding GitHub Flow

GitHub Flow is a simple and effective workflow that helps teams collaborate while maintaining code quality. It is based on branches, commits, and pull requests, providing a clear structure for managing change.

Branches: Isolated Development

Branches allow developers to work on features or fixes without affecting the main codebase. Each branch acts as an isolated workspace where changes can be tested safely before integration.

Commits: Recording Progress

A commit represents a snapshot of changes made to files. Each commit includes metadata such as the author, timestamp, and a descriptive message, ensuring a transparent project history.

Files move through clear stages — from untracked to committed — ensuring changes are intentional and traceable.

Pull Requests: Reviewing and Merging Changes

Pull requests are used to propose merging changes from one branch into another. They enable code review, discussion, and approval before changes become part of the main branch. Draft pull requests support early collaboration on work in progress.

The GitHub Flow in Practice

A typical GitHub Flow follows these steps:

Create a new branch.
Make incremental commits.
Open a pull request.
Review and discuss changes.
Merge the pull request.
Delete the branch once complete.

This lightweight workflow is ideal for continuous delivery and fast-moving teams.

Git Flow: A Structured Alternative

Git Flow is a more formal branching model designed for release-based development. It introduces dedicated branches for development, features, releases, and hotfixes.

Git Flow works well for teams managing scheduled releases or maintaining multiple versions of software, but it is generally heavier and more complex than GitHub Flow, which prioritizes speed and flexibility.

Module 3: Introduction to GitHub Products

GitHub offers a range of account types and plans designed to support individuals, teams, and large enterprises. Understanding these options is essential for selecting the right balance of collaboration features, security controls, and scalability based on your needs.

GitHub Account Types

GitHub provides three primary account types: Personal, Organization, and Enterprise. Each serves a distinct purpose and offers different levels of control and governance.

Personal Accounts

A personal account represents an individual developer’s identity on GitHub. Every user who signs up receives a unique username and profile.

With a personal account, you can:

Create and own repositories, packages, and projects
Collaborate on public and private repositories
Contribute to other projects through pull requests and issues

All activity — such as commits, reviews, and comments — is attributed to your personal account.

Available plans:

GitHub Free
GitHub Pro

Organization Accounts

Organization accounts provide shared workspaces for teams. Members access the organization using their personal accounts, while permissions are managed through roles and teams.

Key capabilities include:

Unlimited members and collaborators
Team-based permission and access control
Shared ownership of repositories and packages

Organization owners and security managers can enforce policies, manage settings, and protect sensitive data at scale.

Enterprise Accounts

Enterprise accounts are designed for large organizations managing multiple organizations under a centralized structure.

Enterprise administrators can:

Enforce security and compliance policies across all organizations
Manage authentication and billing centrally
Enable inner sourcing by sharing code internally between teams

Enterprise accounts support integration with external identity providers to ensure secure and consistent access management.

GitHub Plans and Pricing

Once an account type is selected, the next step is choosing a plan that aligns with your workflow and team size.

GitHub Free

GitHub Free is ideal for individuals and small teams getting started.

For personal accounts:

Unlimited public and private repositories
Unlimited collaborators
Limited GitHub Actions minutes and Codespaces usage
Basic community support

For organizations:

Unlimited repositories and collaborators
Team-based access controls

This plan is well suited for learning, open-source contributions, and small-scale collaboration.

GitHub Pro

GitHub Pro is designed for individual developers who require more advanced tooling.

In addition to Free features, it includes:

Email support
Increased GitHub Actions and Packages limits
Protected branches and required reviewers
Repository insights, Wikis, and GitHub Pages

This plan works well for freelancers and developers managing multiple private projects.

GitHub Team

GitHub Team supports organizations that need stronger collaboration and governance capabilities.

Key additions include:

Team-based access controls
Draft and team pull requests
Scheduled reminders
Advanced repository insights

It is a strong choice for small to mid-sized teams seeking efficient workflows and better coordination.

GitHub Enterprise

GitHub Enterprise is the most comprehensive plan, built for large-scale operations with advanced security and compliance requirements.

Enterprise features include:

Centralized policy enforcement
Enterprise-grade identity and access management
Advanced security and auditing tools
Dedicated enterprise support

Enterprise Deployment Options

GitHub Enterprise Cloud: Fully managed by GitHub with high availability and centralized billing
GitHub Enterprise Server: Self-hosted solution for organizations with strict infrastructure or data requirements

Enterprise Managed Users (EMU)

Enterprise Managed Users allow organizations to manage GitHub accounts using their own identity providers, such as Azure AD or Okta. This ensures consistent authentication policies and simplifies administration across large teams.

GitHub Copilot Availability

GitHub Copilot is not included by default in standard plans. However, Copilot Business and Copilot Enterprise can be added as separate subscriptions to enhance developer productivity with AI-assisted coding.

Understanding GitHub Billing and Payments

GitHub’s billing system is designed to scale with usage and organizational needs while maintaining transparency and control.

How Billing Works

Billing is organized by account type:

Personal
Organization
Enterprise

Each account typically has its own bill, though enterprises can consolidate billing across multiple organizations.

Billing consists of:

Subscription charges for plans and add-ons
Usage-based charges for services such as GitHub Actions, Packages, and Codespaces

Most plans include a baseline amount of free usage, with spending limits available to control overages.

GitHub Actions Pricing

GitHub Actions pricing depends on repository visibility:

Public repositories: Unlimited free minutes
Private repositories: Metered usage based on plan limits

Monitoring usage is essential to avoid unexpected charges, particularly in automation-heavy projects.

Usage-Based License Billing

GitHub supports usage-based billing for licenses, allowing organizations to pay only for what they use.

Key characteristics:

Monthly billing based on active license usage
Pro-rata charges for mid-month changes
Automatic adjustments when license usage changes

This model provides flexibility and cost efficiency without requiring upfront bulk purchases.

GitHub’s Enhanced Billing Platform

GitHub’s billing platform offers advanced financial management tools, including:

Spending limits for usage-based services
Detailed consumption insights
Automated reports for cost tracking and allocation

Additional considerations:

Codespaces are billed separately based on compute and storage usage
Billing alerts notify administrators when spending approaches defined limits

These features help organizations maintain budget control while gaining clear visibility into resource usage.

Module 4: Configure Code Scanning on GitHub

Code scanning is a security and code quality feature that analyzes source code to detect vulnerabilities and programming errors. It helps teams prevent new security issues and identify existing problems early in the development lifecycle.

Scan results appear as alerts in the Security tab of a GitHub repository. These alerts are automatically closed once the underlying issue is fixed.

At the core of GitHub’s code scanning is CodeQL, GitHub’s powerful code analysis engine. CodeQL treats code as data, allowing sophisticated queries to detect security flaws and quality issues with high accuracy.

Key Features of Code Scanning

Code scanning provides several important capabilities:

Detects security vulnerabilities and common coding errors
Supports multiple programming languages, including:
C / C++
C#
Go
Java / Kotlin
JavaScript / TypeScript
Python
Ruby
Swift

Available for:

Public repositories (free)
Private repositories with GitHub Advanced Security

How Code Scanning Works

Code scanning follows a structured process:

CodeQL Database Creation
A database is generated that represents the structure and behavior of the code.
Running CodeQL Queries
Predefined or custom queries are executed against the database to identify potential issues.
Alerts and Feedback
Results are displayed as code scanning alerts in GitHub. When the vulnerable code is fixed, related alerts are automatically resolved.

This workflow enables continuous security monitoring with minimal manual effort.

Code Scanning Setup Options

GitHub provides multiple ways to configure code scanning depending on your needs.

Default Setup

The default setup is the fastest way to get started:

Automatically configured using GitHub Actions
GitHub selects supported languages and query suites
Runs automatically on:

push

pull_request events

This option is ideal for most repositories and requires little to no manual configuration.

Advanced Setup

Advanced setup allows full customization:

1- Adds a CodeQL workflow file to the repository

2- Enables manual control over:

Queries
Triggers
Workflow steps

This option is recommended for teams with specific security policies or custom analysis requirements.

Get Sule Akturk’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

External CI Setup

Code scanning can also be executed outside GitHub:

Run CodeQL CLI on an external system
Upload analysis results back to GitHub
Suitable for complex CI environments or restricted infrastructures

When Code Scanning Runs (Triggers)

Code scanning can be triggered automatically when:

Code is pushed to a protected branch
A pull request is opened against the default branch

This ensures new changes are analyzed before being merged into critical branches.

Billing Considerations

Code scanning runs on GitHub Actions, so usage affects your Actions quota:

Public repositories: Free
Private repositories: Consumes Action minutes based on your plan
(Free, Pro, Team, or Enterprise)

Additional usage beyond the included quota may incur extra charges.

External Analysis and SARIF Integration

Instead of running code scanning directly on GitHub, you can analyze code externally using tools such as ESLint, SonarQube, or custom static analysis tools.

The results must be uploaded to GitHub in SARIF format.

Required format: SARIF (Static Analysis Results Interchange Format) v2.1.0
Uploaded results appear in the Security tab, just like native GitHub scans

Ways to Upload SARIF Files

There are three primary methods to upload SARIF results.

Upload via GitHub REST API

You can manage code scanning alerts programmatically:

Use code scanning API endpoints
Example endpoint:

/orgs/ORG/code-scanning/alerts

Requires the application/sarif+json media type
Useful for automated or offline analysis pipelines

Upload via CodeQL CLI

The CodeQL CLI allows you to:

Generate a CodeQL database
Run queries locally
Export results as a SARIF file
Upload results to GitHub

Note: Private repositories require a GitHub Advanced Security license.

Upload via GitHub Actions

GitHub Actions can automate SARIF uploads as part of your CI pipeline.

Example GitHub Actions Workflow

name: "Upload SARIF"
on:
  push:
  schedule:
    - cron: '45 15 * * 4' # Runs weekly

jobs:
  build:
    runs-on: ubuntu-latest
    permissions:
      security-events: write
    steps:
      - name: Checkout repository
        uses: actions/checkout@v2

      - name: Upload SARIF file
        uses: github/codeql-action/upload-sarif@v1
        with:
          sarif_file: results.sarif

Important Notes

Supports single SARIF files or directories
Can run on push or on a scheduled basis
Supports partialFingerprints to avoid duplicate alerts

Maximum:

5,000 results per upload
10 MB compressed SARIF file size

CI Integration with External Tools

If your CI pipeline generates SARIF output, you can upload it directly to GitHub.

Example with ESLint

- name: Run ESLint
  run: eslint . -f sarif -o results.sarif

- name: Upload SARIF file
  uses: github/codeql-action/upload-sarif@v1
  with:
    sarif_file: results.sarif

Once uploaded, GitHub processes the SARIF file and displays alerts in the repository’s Security tab.

Summary

Code scanning detects vulnerabilities and quality issues automatically
Powered by CodeQL
Supports native scans and external tools
SARIF enables flexible security integration
Alerts are centralized in GitHub for visibility and collaboration

Module 5: GitHub Copilot

GitHub Copilot is an AI pair programmer developed by GitHub and OpenAI (powered by OpenAI Codex). It helps developers:

Autocomplete code and comments.
Generate unit tests.
Suggest bug fixes.
Assist across the entire development lifecycle.

It integrates with VS Code, Visual Studio, Vim/Neovim, and JetBrains IDEs.

Key Benefits

46% of new code is AI-generated for Copilot users.
55% faster productivity on real-world projects.
74% of developers report feeling more focused on satisfying work.

Copilot Features

Copilot for Chat

ChatGPT-like interface inside the IDE.
Can explain code, generate tests, and suggest bug fixes.

2. Copilot for Pull Requests

AI-generated PR tags and descriptions.
Helps summarize code changes automatically.

3. Copilot for CLI

Compose commands and loops for the terminal.
Reduces need to remember exact command syntax.

1. Inline Suggestions

Provides real-time code completions as you type.
Accept with Tab or right arrow, reject with Esc.
Useful for repetitive or boilerplate code.

2. Command Palette

Quick access to Copilot functions.
Allows generating explanations, unit tests, and other actions via shortcuts.

3. Copilot Chat

Interactive chat within the IDE using natural language.
Ask questions or request code snippets.

4. Inline Chat

Context-specific conversations directly in the code editor.
Request modifications or explanations for a specific code section.

5. Slash Commands

Quick commands to interact with Copilot:

/explain — Explains code
/suggest — Offers code suggestions
/tests — Generates unit tests
/comment — Converts comments into code

6. Comments to Code

Describe functionality in a comment, Copilot generates the corresponding code.

7. Multiple Suggestions

Cycle through alternative code suggestions to choose the best approach.

8. Explanations

Get explanations for selected code blocks to understand or review them.

9. Automated Test Generation

Automatically generates unit tests for functions or classes.

Module 6: Code with GitHub Codespaces

GitHub Codespaces is configurable, allowing you to create a customized development environment for your project. By configuring a custom development environment for your project, you can have a repeatable Codespace configuration for all users of your project.

You can create a Codespace on GitHub.com, in Visual Studio Code, or by GitHub CLI. There are four ways to create a Codespace:

From a GitHub template or any template repository on GitHub.com to start a new project.
From a branch in your repository, for new feature work.
From an open pull request, to explore work-in-progress.
From a commit in a repository’s history to investigate a bug at a specific point in time.

When you create a GitHub Codespace, four processes occur:

A virtual machine and storage are assigned to your Codespace.
A container is created.
A connection to the Codespace is made.
A post-creation setup is made.

When you rebuild the container in a Codespace, changes you made outside the /workspaces directory are cleared. Changes you made inside the /workspaces directory, including the clone of the repository or template you created the Codespace from, are preserved over a rebuild.

Module 7: Manage Your Work with GitHub Projects

GitHub has reimagined how we plan, track, and manage work. The new GitHub Projects goes far beyond “Projects (Classic),” offering a more flexible, data-driven, and customizable experience for teams and individuals.

Tables & Boards

In the new Projects, you can work with tables or boards — whichever fits your workflow.
You can rank, sort, and group items by any custom field, create draft issues with full descriptions, and use token-based filters to customize your view.
Real-time updates and user presence indicators make collaboration seamless.

Data & Custom Fields

Unlike the limited columns of Classic Projects, the new Projects lets you define custom fields — text, number, date, iteration, or single select.
You can even configure iterations for agile sprints or quarterly planning and see linked pull requests and reviewers directly in your view.

Insights & Reporting

Projects now includes built-in charts (bar, line, column, stacked area) that you can fully customize.
Use functions like sum, count, average, min, or max to gain instant visibility into progress, and share charts easily via unique URLs.

Automation

Automation is now smarter and more powerful:

GraphQL ProjectsV2 API for advanced integration
Webhooks for real-time updates
GitHub Actions to automate adding or updating project items

Mastering Project Management: Visibility, Automation, and Insights

After successfully setting up your Project and adding initial issues and pull requests, the next crucial steps involve providing visibility, optimizing organization, gaining actionable insights, and implementing automation. These capabilities ensure your team stays organized and on track.

Here is a recap of how to effectively manage the structure, access, and lifecycle of your project based on the provided training material.

1. Organizing Your Work for Focus

Effective organization starts with structured fields and customized views.

Utilizing Priority and Iteration Fields

To keep track of ongoing work, you can create custom fields in the table view:

Priority Fields: Use the Single select field type to create classifications like Urgent, High, Medium, and Low. Once classified, you can Group by Priority to easily focus on high-priority items. A key feature of this view is the ability to drag and drop issues into new priority fields.
Iteration Fields: Adding an Iteration field (e.g., named Project Phase or Sprint) helps visualize the balance of upcoming work in tangible timeframes. When setting up an Iteration field, you define the Starts On date and the Duration (in days or weeks).

Creating Visual Board Views

While the table view is useful for data entry, a Board layout provides a more visual way to view upcoming tasks. You can change the layout of your currently open view by selecting the down arrow and choosing Board under Layout. In the board view, you can drag and drop issues and pull requests between columns. Remember to save your modified views.

Converting Checklist Items

For better task tracking and hierarchy, GitHub Projects supports converting checklist items into sub-issues. This creates a dedicated, linked issue that appears in your Project view.

2. Controlling Visibility and Managing Access

A core aspect of project management is defining who can see and interact with your project.

Setting Project Visibility

You can control whether your project is public (viewable by everyone on the internet) or private (viewable only by users granted at least read access).

To change visibility, navigate to your Project, select the three dots menu, choose Settings, scroll to the Danger zone, and select Private or Public under Visibility.

Understanding Access Levels

Project access management differs depending on whether the Project is organization-owned or personal/user-owned:

Admins of organization-owned Projects can manage access for the entire organization, teams, individual members, and outside collaborators, while admins of user-owned Projects can invite and manage individual collaborators.

You can invite collaborators or change their roles by navigating to Settings and selecting Manage access from the left-hand navigation bar.

Linking Projects to Teams and Repositories

Add to a Team: Adding a Project to a team grants the team read permissions and lists the Project on the team’s Projects page, making it easier for members to identify the Projects their team uses.
Add to a Repository: You can list relevant Projects in a repository, but only if the same user or organization owns both the Project and the repository. Repository members must also have visibility to the Project to see it listed.

3. Leveraging Insights and Automation

Projects offer methods to visualize progress and automate routine tasks.

Gaining Insights with Charts

Insights enable you to view, create, and customize charts using Project items as source data. Charts are available to anyone who can view the Project.

Current Charts: These charts visualize the current state of your Project items, such as the number of items assigned to each individual or items per upcoming iteration. Filters can be used to manipulate the displayed data.

Historical Charts: Available with GitHub Team and GitHub Enterprise Cloud for organizations, these are time-based charts that show trends and progress. The default Burn up chart visualizes item status over time, helping to spot patterns.

To create a new chart, navigate to your Project, select the Insights line graph button in the top-right, and choose New chart. You can customize the chart by selecting Configure on the right side to change the Layout and the fields used for the X-axis and Group by function.

Automating Tasks

You can automate your Project using three methods: built-in automated workflows (easiest), GraphQL API, or GitHub Actions with workflows.

Built-in Workflows: These help keep you aware of work, for instance, by taking newly created issues or pull requests and automatically putting them into your Project with a Todo status.

To enable a default workflow:

Select the three dots menu and choose Workflows.
Select a trigger, such as Item added to project.
Configure the status (e.g., select Status:Todo in the Set Value section).
Select Save and turn on workflow.

GitHub Actions: This method offers the most customization, allowing you to create workflows that automate project management tasks, such as adding a label, leaving a comment, and moving an issue to a project board upon issue creation.

4. Closing and Deleting Projects

Once a Project is complete or no longer needed, you can manage its lifecycle. Both closing and deleting options are found in the Danger zone section of the Project Settings.

Closing a Project: This is recommended to preserve your data. Closing removes the Project from the list but retains the content and the ability to reopen it later.
Deleting a Project: This action permanently removes the Project from the platform, along with associated saved views, custom fields, insights data, and drafted issues. Selecting Delete project prompts you to read warnings and requires typing the name of the Project for confirmation.

Module 8: Communicate Effectively on GitHub Using Markdown

Markdown is a lightweight markup language designed to make content creation simple and efficient. It allows developers and content creators to focus on writing without dealing with the complexity of HTML, while still providing enough power to structure and format content effectively.

In this module from Microsoft Learn, Markdown is introduced along with its structure, syntax, and the additional features provided by GitHub-Flavored Markdown (GFM) — a set of extensions that make collaboration on GitHub easier and more efficient.

Basic Markdown Syntax

Markdown provides intuitive syntax for formatting text and organizing content.

Emphasis

Text can be styled for emphasis in multiple ways:

Italic text is created using single asterisks (*) or underscores (_)
Bold text uses double asterisks (**) or double underscores (__)
Mixed emphasis is also possible, such as:
_This is **italic and bold** text_

To display literal asterisks or underscores instead of triggering formatting, you can escape them using a backslash (\) in GitHub-Flavored Markdown.

Headings

Headings use the hash symbol (#) to define hierarchy.
Markdown supports six heading levels:

# Heading 1
## Heading 2
###### Heading 6

Each additional hash represents a lower-level heading.

Lists and Tables

Markdown supports both ordered and unordered lists:

Ordered lists use numbers
Unordered lists use asterisks (*) or hyphens (-)
Nested list items are created using indentation

Tables are created using pipes (|) to separate columns and dashes (-) to define header rows.

Links and Quotes

Links and images follow a similar syntax structure
Blockquotes are created using the greater-than symbol (>)

These features make it easy to reference documentation, external resources, or important notes.

Code Blocks

Markdown allows both inline and multi-line code formatting:

Inline code is wrapped in backticks (`)
Multi-line code uses fenced code blocks with three backticks (```)

If a formatting need is not supported by Markdown, HTML can be used inline to bridge the gap — for example, to insert a line break (<br>).

GitHub-Flavored Markdown (GFM) Enhancements

GitHub extends standard Markdown to better support collaboration, code review, and project tracking.

Syntax Highlighting

GFM enables syntax highlighting by specifying the language after the opening triple backticks:

console.log("Hello, GitHub!");

This makes code easier to read and understand.

Cross-linking

GitHub allows easy linking to issues, pull requests, and commits:

Use #ID to reference issues or pull requests (e.g., #3602)
Paste a commit hash (SHA) to link directly to a commit

Mentions and Task Tracking

Typing @username mentions a user or team and sends a notification
Task lists help track progress inside issues and pull requests:

- [x] First task
- [ ] Second task

Slash Commands

Slash commands help you create structured content faster in comment and description fields. Common commands include:

/code – Inserts a Markdown code block
/table – Inserts a Markdown table
/tasklist – Inserts a task list in an issue or pull request

These shortcuts reduce friction and help maintain consistency across GitHub content.

Markdown, especially with GitHub-Flavored extensions, is an essential tool for effective communication on GitHub. It enables clear documentation, better collaboration, and more readable code discussions — all without leaving the comfort of plain text.