<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Sule Akturk on Medium]]></title>
        <description><![CDATA[Stories by Sule Akturk on Medium]]></description>
        <link>https://medium.com/@suleakturk?source=rss-4381f97e14d2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*aX8qYaH5paPXWkjrPxr0Jg.jpeg</url>
            <title>Stories by Sule Akturk on Medium</title>
            <link>https://medium.com/@suleakturk?source=rss-4381f97e14d2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 00:30:10 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@suleakturk/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Automating Dependency Handoffs in Azure Boards with Copilot Studio]]></title>
            <link>https://medium.com/@suleakturk/automating-dependency-handoffs-in-azure-boards-with-copilot-studio-22349f44a48c?source=rss-4381f97e14d2------2</link>
            <guid isPermaLink="false">https://medium.com/p/22349f44a48c</guid>
            <category><![CDATA[copilot-studio]]></category>
            <category><![CDATA[microsoft-copilot-studio]]></category>
            <category><![CDATA[microsoft-azure]]></category>
            <category><![CDATA[workflow-automation]]></category>
            <dc:creator><![CDATA[Sule Akturk]]></dc:creator>
            <pubDate>Sat, 31 Oct 2026 15:44:44 GMT</pubDate>
            <atom:updated>2026-10-31T15:44:44.570Z</atom:updated>
            <content:encoded><![CDATA[<h4>How I built a low-cost workflow that tells teammates the moment the work they’re waiting on is done.</h4><p>Every sprint, our team asked the same question in chat: <em>“Is the API ready yet?”</em> A frontend task waits for a backend task. A backend task waits for a design. Nobody wants to keep refreshing the board.</p><p>So I built <strong>Ready Handoff</strong>: a small workflow in Microsoft Copilot Studio. When a work item moves to <strong>Test</strong>, everyone waiting on it gets a Teams card within a few minutes. If the waiting item has no owner yet, it gets a <strong>Ready to Work</strong> tag on the board.</p><p>In this post I’ll show the design, the build step by step, why it costs almost nothing to run, and the gotchas I hit along the way.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/640/1*pK_RsK1ISmNOiYZWvGlrhQ.png" /></figure><h3>Copilot Studio in one minute</h3><p>Copilot Studio gives you two building blocks, and picking the right one is most of the design.</p><ul><li><strong>Agents</strong> think. You give them instructions and tools, and they decide what to call and in which order. Great for open-ended questions like <em>“summarize my open items”</em>.</li><li><strong>Workflows</strong> follow steps. A trigger starts them, and every node does exactly one thing: read data, check a condition, loop, send a message. Same input, same result, every time.</li></ul><p>Notifying the right person when a work item changes is a rules job, not a thinking job. So Ready Handoff is a <strong>workflow with no AI in it at all</strong>. That choice is what keeps it reliable and cheap.</p><blockquote><em>Rule of thumb: use AI where judgment adds value, and plain steps everywhere else.</em></blockquote><h3>How it works</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ySiPWjM2S1ry14lfHOnCTw.png" /></figure><p>Most updates stop at the first decision. Only a fresh move to Test fetches the links, checks each waiting item, and sends a card or adds a tag.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CZQxhxee8m04mGrpSOxnbQ.png" /></figure><p>The same flow as it looks in the Copilot Studio canvas.</p><h3>Building it, step by step</h3><p>The whole flow is eight steps. I’ll use a mock project called <strong>Phoenix</strong> in an organization called <strong>contoso</strong>, with two work items:</p><ul><li><strong>#1201 Payments API: add refund endpoint</strong> — Backend, owned by Alex Kim</li><li><strong>#347059 Checkout UI: refund button</strong> — Frontend, owned by Jordan Lee, linked to #1201 as its <strong>Predecessor</strong></li></ul><h3>Step 0: Agree on one link type</h3><p>The automation is only as good as the links on the board. We use Azure DevOps’ built-in <strong>Predecessor / Successor</strong> link: the waiting item adds the item it waits on as its Predecessor. Unlike <em>Related</em>, this link has a direction, so we always know who is waiting for whom.</p><p>In our example, #347059 (Checkout UI) lists #1201 (Payments API) as its Predecessor.</p><h3>Step 1: Trigger and parse</h3><p>The trigger is the Azure DevOps connector’s <strong>When a work item is updated</strong>. It fires for every change in the project, so the next steps must filter fast.</p><p>The trigger returns the work item’s fields as one object, so a <strong>Parse JSON</strong> node turns it into fields I can use in conditions: System_State, System_ChangedDate and Microsoft_VSTS_Common_StateChangeDate.</p><h3>Step 2: The smart filter</h3><p>An <strong>If/Else</strong> node lets the run continue only when both are true:</p><ul><li>System_State equals <strong>Test</strong></li><li>StateChangeDate equals ChangedDate</li></ul><p>The second check is my favourite trick. If the last change <em>was</em> the state change, the two timestamps match. If someone just added a comment to an item that’s already in Test, they don’t. No tags, no extra storage, and no duplicate notifications.</p><h3>Step 3: Fetch the item with its links</h3><p>The connector’s <strong>Send an HTTP request to Azure DevOps</strong> action calls the REST API directly:</p><pre>GET Phoenix/_apis/wit/workitems/1201?$expand=relations&amp;api-version=7.1</pre><p>$expand=relations returns every link on the item, including the successors.</p><h3>Step 4: Keep only the successors</h3><p>A <strong>Filter array</strong> node keeps the links whose rel is System.LinkTypes.Dependency-Forward, which is the API&#39;s name for <em>Successor</em>. Wrapping the input in coalesce(..., json(&#39;[]&#39;)) means items with no links simply produce an empty list instead of an error.</p><h3>Step 5: Loop over the waiting items</h3><p>A <strong>For each</strong> loop runs once per successor. Inside, a second HTTP request fetches the successor’s details. The item ID comes from the end of its URL:</p><pre>last(split(item()?[&#39;url&#39;], &#39;/&#39;))</pre><h3>Step 6: Two quick decisions</h3><p>Two nested If/Else nodes decide what to do:</p><ol><li><strong>Is it still open?</strong> If the successor is already in Test, Done or Removed, skip it.</li><li><strong>Does it have an owner?</strong> Check whether System.AssignedTo is empty.</li></ol><h3>Step 7: Notify with an Adaptive Card</h3><p>If the waiting item has an owner, the workflow posts an <strong>Adaptive Card</strong> to them through the Teams <strong>Flow bot</strong>. The card shows both items and has two buttons to open them.</p><p>This is the card shown at the top of this post.</p><h3>Step 8: No owner? Tag it</h3><p>If nobody owns the waiting item, two things happen:</p><ul><li>The owner of the <em>ready</em> item gets a card saying the next item is unassigned.</li><li>The waiting item gets a <strong>Ready to Work</strong> tag, so it stands out on the board during planning.</li></ul><p>One detail matters here: writing System.Tags through the API replaces all existing tags. The expression first reads the current tags and appends the new one, and skips the write if the tag is already there.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/636/1*TM42VKsQCOl9BgznHs_0wA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/285/1*67uOKiVMiNJCeWmRaqxvvQ.png" /></figure><h3>Why it costs almost nothing</h3><p>The expensive part of Copilot Studio is AI: every time an agent reasons or calls a tool, it consumes Copilot credits. Ready Handoff never calls an agent, so most of what it does is free or close to free.</p><ul><li><strong>Every update in the project</strong> runs only the trigger, Parse JSON and the first If/Else: a few simple workflow actions.</li><li><strong>HTTP calls to Azure DevOps</strong> run only when an item reaches Test. They cost nothing; one call used about 0.8% of the API rate limit.</li><li><strong>The loop, conditions and tag update</strong> also run only when an item reaches Test: a handful of simple actions.</li><li><strong>Teams cards via Flow bot</strong> go out once per waiting person, at no charge.</li><li><strong>AI agent reasoning</strong> never runs, so it costs nothing.</li></ul><p>The filter in Step 2 does the heavy lifting. Most updates are comments and field edits, and they stop at the very first condition.</p><p>If you want an exact number for your tenant, check consumption in the Power Platform admin center. Pricing changes, so I’m not quoting credit rates here.</p><h3>What changed for the team</h3><ul><li><strong>No more “is it ready?” messages.</strong> The person waiting finds out within minutes, with a direct link.</li><li><strong>Unowned work stays visible.</strong> The Ready to Work tag surfaces unblocked items during sprint planning.</li><li><strong>Dependencies became explicit.</strong> To get notified, people link their items, and the board now shows who waits for whom.</li><li><strong>Predictable and cheap.</strong> No AI in the loop means the same result every time and almost no credit use.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=22349f44a48c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stop Passing companyId Everywhere]]></title>
            <link>https://medium.com/@suleakturk/stop-passing-companyid-everywhere-5479f9715ba9?source=rss-4381f97e14d2------2</link>
            <guid isPermaLink="false">https://medium.com/p/5479f9715ba9</guid>
            <category><![CDATA[backend-development]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[multitenancy]]></category>
            <category><![CDATA[api-design]]></category>
            <category><![CDATA[security]]></category>
            <dc:creator><![CDATA[Sule Akturk]]></dc:creator>
            <pubDate>Tue, 07 Jul 2026 11:57:50 GMT</pubDate>
            <atom:updated>2026-07-07T12:04:40.286Z</atom:updated>
            <content:encoded><![CDATA[<p><em>How we handled multi-company context in a multi-tenant SaaS — without giving up security.</em></p><p><strong>The Setup</strong></p><p>If you’ve built a multi-tenant SaaS, you already know the first isolation boundary: <strong>tenant</strong>. One customer’s data must never leak into another’s. That part is usually solved early, and most teams get comfortable with it.</p><p>But there’s a second, quieter problem that shows up once your product grows: <strong>a single tenant can own multiple companies</strong>, and a user needs to act on behalf of one of them — often switching between them in the same session, from a dropdown at the top of the screen.</p><p>The naive fix is to pass a `companyId` everywhere: as a query parameter, a body field, a prop drilled through every request. It works, technically. It also:</p><p>- Pollutes every endpoint and every DTO with a field that has nothing to do with the actual business logic</p><p>- Turns isolation into something every single service has to remember to filter by — and someone, eventually, forgets</p><p>- Makes “switching company” feel like a heavyweight operation instead of a lightweight context change</p><p>There’s also a sharper, more concrete failure mode hiding behind “someone forgets to filter.” If `companyId` is something the client sends — a query param, a body field — then the <em>_only_</em> thing standing between a user and another company’s data is every single endpoint remembering to double-check that the id in the request actually belongs to them. Miss that check once, on one endpoint, and a user can view or modify another company’s invoices, vehicles, or records just by changing a number in the request. This is a textbook IDOR (Insecure Direct Object Reference) — and it doesn’t take a malicious actor to trigger it either; it’s just as often found by an automated scanner, or reported by a confused customer who noticed data that clearly isn’t theirs. The more endpoints you have, the less realistic it is to assume everyone remembers, every time.</p><p>We wanted something different: a <strong>single cross-cutting channel</strong> for “which company am I acting as right now,” decoupled from the request payload entirely.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ACG2ghZPdAnCk0WG67gbYw.png" /></figure><p><strong>The Core Idea: A Header, With a Fallback</strong></p><p>The design settles on one rule, applied consistently everywhere:</p><p>&gt; If a `X-Company-Id` header is present, treat it as the active company. If it’s absent, fall back to the user’s home company from their JWT.</p><p>This single rule has a nice property: a user who only ever belongs to one company <em>never has to think about this at all</em>. No header, no extra state, nothing changes for them. The complexity only appears — and only needs to be handled — for users who actually have more than one company.</p><p>The home company (baked into the JWT at login) and the active company (resolved at runtime from the header) are deliberately different concepts. The token is not re-issued every time someone switches companies — that would mean a new login flow for what should feel like flipping a dropdown. The active company lives outside the token entirely, resolved per-request.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bNFEEgMGTgfGVFRdNn0Npg.png" /></figure><p><strong>Why Trusting the Header Would Be a Mistake</strong></p><p>Here’s the catch: a header is just something the client sends. Nothing stops a malicious or buggy client from sending a company ID that isn’t theirs — including a company that belongs to a <em>different tenant altogether</em>. If the backend blindly trusted the header, this becomes a textbook <strong>horizontal privilege escalation</strong> vector (essentially an IDOR pattern, just expressed through a header instead of a URL parameter).</p><p>The fix is a dedicated authorization step that runs right after authentication: before any controller logic executes, verify that the company referenced in the header actually belongs to the <em>authenticated user’s tenant</em>. If it doesn’t, the request is rejected outright with a 403 — never silently falling back, never partially processing.</p><p>This separates two concerns that are easy to conflate: authentication proves <em>who you are</em>; this extra check proves <em>what you’re allowed to act as right now</em>. Skipping it means your isolation boundary technically exists in the data model but has a hole in the layer that’s supposed to enforce it.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BT5Na95YOh9OEwhhKzITjw.png" /></figure><p><strong>The Part That Actually Removes the Risk of Human Error</strong></p><p>Validating the header solves the security problem. It doesn’t solve the “someone forgot to filter by company in this one service” problem — that’s a different failure mode, and it’s arguably the more common one in practice, because it doesn’t require malice, just an unlucky Tuesday.</p><p>The answer here is to stop relying on developers to remember at all. Instead of scattering `WHERE company_id = …` across every query, the isolation rule is expressed <strong>once</strong>, at the ORM level, as an automatic filter applied to every entity that belongs to a company. Every read query gets this constraint injected transparently; nobody writing a service method has to think about it.</p><p>This shifts company isolation from “a convention everyone has to follow” to “a property of the data access layer that’s structurally difficult to bypass.” The only way around it is an explicit, visible escape hatch — and that escape hatch should be rare and deliberate, reserved for the handful of cases where cross-company reads are genuinely legitimate (permission checks, the security validation step itself, background jobs).</p><p>Writes work the other way around: since there’s nothing to “filter,” new records simply get stamped with the resolved active company id at creation time, alongside the usual audit fields (who created it, when, soft-delete timestamps instead of hard deletes).</p><p><strong>The Frontend Half of the Contract</strong></p><p>None of this matters if the frontend doesn’t hold up its end of the deal, and this is the part that’s easy to underestimate — it’s not just “add a header,” it’s a small state machine with several deliberate constraints:</p><p><strong>Where the active company lives.</strong> Not in a token, not in memory alone — in a small piece of global state, persisted to local storage so it survives a refresh, and cleared automatically on logout so a new session never inherits a stale company.</p><p><strong>Where the header actually gets attached.</strong> Rather than adding it to individual requests, it’s injected in exactly one place — a shared request layer that every API call passes through — and, importantly, <em>_only_</em> on the subset of routes that actually expose a company switcher. Pages without a switcher always operate in the home-company context, regardless of what was selected elsewhere in the app. This scoping decision matters more than it looks: without it, a company switch made in one part of the product silently leaks into unrelated pages.</p><p><strong>What happens on write, when nothing is selected.</strong> Reads can safely fall back to the home company when no company is actively selected. Writes are treated more cautiously — on pages where company context is ambiguous, a mutation without an explicit selection is blocked client-side with a clear message, rather than letting it quietly land against a default the user didn’t consciously choose.</p><p><strong>What happens when the backend says no. </strong>If the backend’s validation step rejects a stale or invalid company id — which does happen, e.g. after switching accounts or when local storage holds an id that’s no longer valid — the frontend needs a defined recovery path: clear the selection and redirect, rather than looping the user through repeated failed requests.</p><p><strong>Why a full page reload, and not something more elegant.</strong> When the company switch happens, all already-cached data across the app is, by definition, scoped to the <em>_old_</em> company. And it’s not just the cache: any request still in flight at the moment of the switch is carrying the old header, and its response would land on a screen that now belongs to the new context — a subtle way to end up with mixed data from two companies on one page. A full reload is a blunt instrument, but it solves both problems at once: every cached view is discarded, and every in-flight request dies with the old page. It’s a trade of elegance for correctness, and for a context-switching action that isn’t performance-critical, that’s usually the right trade.</p><p><strong>The Uncomfortable Truth About This Kind of Design</strong></p><p>The rule sounds simple — “header, or fall back to home company” — but it ends up implemented in more than one place: at least twice on the backend (once for authorization enforcement, once for the actual data filter), and once more on the frontend. Three independent implementations of the same logic, that all need to agree, forever.</p><p>That’s not a flaw unique to this approach — it’s the honest cost of any cross-cutting concern that spans a network boundary. The mitigation isn’t to eliminate the duplication (you can’t, really) but to be deliberate about it: keep each implementation as thin and boring as possible, document the rule in one canonical place, and treat any change to it as touching three systems, not one.</p><p><strong>Takeaways</strong></p><p>If you’re building something similar, the pattern that held up well is:</p><p>1. <strong>Carry cross-cutting context in a header, not the payload</strong> — it keeps business logic and access context cleanly separated.</p><p>2. <strong>Never trust a header for authorization </strong>— validate it against the authenticated identity before it’s allowed to influence anything.</p><p>3. <strong>Enforce isolation structurally</strong> (a global filter at the data layer), not conventionally (a rule developers are expected to remember).</p><p>4. <strong>Scope the frontend’s use of the header</strong> to exactly the pages that need it — don’t let context leak app-wide by default.</p><p>5. <strong>Have an explicit recovery path</strong> for the moment validation fails, instead of assuming it never will.</p><p>None of these ideas are exotic on their own. What makes the system work is that they’re applied <em>consistently</em>, on both sides of the network boundary, as one coherent rule rather than a pile of individual fixes.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5479f9715ba9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GitHub Foundations Certification Part -2]]></title>
            <link>https://medium.com/@suleakturk/github-foundations-certification-eb8651c4c573?source=rss-4381f97e14d2------2</link>
            <guid isPermaLink="false">https://medium.com/p/eb8651c4c573</guid>
            <category><![CDATA[github-copilot]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[github-pages]]></category>
            <category><![CDATA[github-actions]]></category>
            <category><![CDATA[github-foundations]]></category>
            <dc:creator><![CDATA[Sule Akturk]]></dc:creator>
            <pubDate>Mon, 22 Dec 2025 22:44:17 GMT</pubDate>
            <atom:updated>2025-12-22T22:47:17.061Z</atom:updated>
            <content:encoded><![CDATA[<p>In the first part of this series, we covered the foundational tools and features that form the backbone of GitHub’s ecosystem, ranging from the basics of Git and GitHub to advanced tools like GitHub Copilot and GitHub Projects. In this second part, we are diving deeper into more advanced topics and best practices that will help you not only enhance your workflow but also contribute to and manage projects more effectively.</p><p>This section will cover essential areas like contributing to open-source projects, managing repositories securely, and administering GitHub environments. You will also learn about practical tools and strategies for maintaining a secure codebase, automating workflows, and even using GitHub in combination with Python through GitHub Copilot.</p><p>The topics for this section are organized as follows:</p><ul><li><strong>Module 1:</strong> Contribute to an Open-Source Project on GitHub</li><li><strong>Module 2:</strong> Manage an InnerSource Program Using GitHub</li><li><strong>Module 3:</strong> Maintain a Secure Repository Using GitHub Best Practices</li><li><strong>Module 4:</strong> Introduction to GitHub Administration</li><li><strong>Module 5:</strong> Authenticate and Authorize User Identities on GitHub</li><li><strong>Module 6:</strong> Manage Repository Changes Using Pull Requests on GitHub</li><li><strong>Module 7:</strong> Search and Organize Repository History on GitHub</li><li><strong>Module 8:</strong> Using GitHub Copilot with Python</li></ul><h3><strong>Module 1: Contribute to an Open-Source Project on GitHub</strong></h3><p>Getting involved in open source can feel intimidating at first — especially if you think it’s all about writing complex code. <br>The truth is, open source thrives on <em>diversity</em> — of skills, ideas, and perspectives. <br>Whether you’re a developer, designer, writer, or problem-solver, there’s a place for you to contribute and grow.</p><p>Here’s how to find where you can make the most impact.</p><p><strong>1. Find What Inspires You</strong></p><p>Before contributing, ask yourself: <em>What kind of projects excite me?</em> <br>Maybe it’s a library you use daily, a tool that simplifies your workflow, or a cause that aligns with your values.</p><p>When you choose something that genuinely interests you, learning and contributing feel natural — not like work. <br>Passion is what turns small contributions into meaningful change.</p><p><strong>2. Discover the Right Projects</strong></p><p>The open source world is huge — so start small. <br>Platforms like <strong>GitHub</strong> make it easy to discover projects looking for help.</p><p>Look for labels such as:</p><ul><li><strong>good first issue</strong> — beginner-friendly tasks</li><li><strong>help wanted</strong> — contributions needed</li><li><strong>documentation</strong> — updates or improvements</li></ul><p>You don’t need to write code from day one. Editing a README, clarifying setup steps, or organizing an issue list are all valuable contributions.</p><p><strong>3. Explore Different Ways to Contribute</strong></p><p>Open source is more than commits and pull requests — it’s collaboration in every form. <br>Here are some non-code ways to make an impact:</p><ul><li><strong>Improve documentation:</strong> fix typos, add examples, or translate guides.</li><li><strong>Design and UX:</strong> suggest interface improvements or create visuals.</li><li><strong>Testing:</strong> report bugs, verify fixes, and share feedback.</li><li><strong>Community:</strong> answer questions, write tutorials, or help others get started.</li></ul><p>Every role matters — projects grow when people share their unique skills.</p><p><strong>4. Start Small, Learn, and Grow</strong></p><p>No one begins as an expert contributor. <br>Your first pull request might fix a small typo — and that’s completely fine. <br>Each step helps you understand how the project works and builds trust with maintainers.</p><p>Over time, you’ll gain confidence, take on more complex issues, and maybe even mentor new contributors. <br>The key is consistency and curiosity — not perfection.</p><h4><strong>How to Contribute to an Open Source Repository</strong></h4><p>Once you’ve identified <em>where</em> to help in open source, the next challenge is <em>how</em> to make that contribution effectively. This stage is less about code — and more about <strong>communication, collaboration, and respect for process</strong>.</p><p><strong>1. Communication Comes First</strong></p><p>Before you write any code, <strong>talk</strong> to the maintainers. <br>Why? Because open source is teamwork.</p><p>If you start working without telling anyone, you might duplicate someone’s effort or build something that doesn’t fit the project’s goals. A short message can save hours of wasted time.</p><p>Always:</p><ul><li>Comment on an existing issue before you start.</li><li>Or, open a new issue to propose your idea.</li><li>Wait for confirmation before diving in.</li></ul><p>Maintainers are usually volunteers — patience and kindness go a long way.</p><p><strong>2. State Your Intent Clearly</strong></p><p>If you want to fix a bug or add a feature, make your intentions public:</p><ul><li>Check if anyone’s already assigned to the issue.</li><li>Leave a comment like:</li></ul><p>“I’d like to work on this one — is it available?”</p><ul><li>If it’s a new idea, describe it briefly and ask for feedback.</li></ul><p>This small step builds trust and shows that you’re collaborating, not just coding.</p><p><strong>3. The Pull Request (PR) in a Nutshell</strong></p><p>A pull request (PR) is how your work officially enters the project. It’s a space for:</p><ul><li>Your proposed changes (commits)</li><li>A short explanation</li><li>A public discussion about those changes</li><li>Automated checks and code reviews</li></ul><p>Basic flow:</p><ol><li>Fork the project.</li><li>Clone it to your machine.</li><li>(Optionally) create a new branch.</li><li>Make and commit your changes.</li><li>Push your branch and open a pull request.</li></ol><p>Each step makes your contribution visible and reviewable — two key traits of successful open source work.</p><p><strong>4. Respect the Review Process</strong></p><p>When you open a PR, it goes through automated <strong>status checks</strong> and <strong>code reviews</strong>. <br>If something fails, don’t panic — it’s normal.</p><p>Read the details, fix what’s needed, and push your updates. Your PR will update automatically. <br>If you’re unsure, politely ask for guidance in the comments — that’s what collaboration looks like.</p><p><strong>5. Learn to Embrace Feedback</strong></p><p>Feedback isn’t rejection — it’s mentorship. <br>Maintainers might request small revisions or ask for clarification. Use it as a chance to learn and improve.</p><p>If your PR is approved, congratulations — your code is now part of something bigger! <br>If it’s not, you still gained valuable experience and insight into the process.</p><p><strong>6. Keep It Public, Respectful, and Patient</strong></p><p>Good etiquette is essential:</p><ul><li>Always discuss issues publicly (no DMs or private messages).</li><li>Be polite in every comment or reply.</li><li>Understand that maintainers are people too — responses may take time.</li></ul><p>Your professionalism leaves a lasting impression and builds your reputation in the open source world.</p><p><strong>Recap</strong></p><p>Here’s the open source contribution cycle in one line:</p><p><strong>Communicate → Confirm → Contribute → Collaborate → Celebrate 🎉</strong></p><p>By being open, patient, and respectful, your work not only strengthens the project — it strengthens <em>you</em> as a developer and community member.</p><h3><strong>Module 2:</strong> Manage an InnerSource Program Using GitHub</h3><p>In the past, software development was divided into two models: <strong>open source</strong> (where anyone can contribute and access the code) and <strong>proprietary</strong> (which keeps the code private for competitive advantage).</p><p>However, some companies want the benefits of open-source practices — like transparency, external contributions, and bug tracking — without giving up their proprietary software. <strong>InnerSource</strong> is the solution, allowing companies to adopt open-source principles internally. By using platforms like GitHub, companies can encourage collaboration, improve discoverability, and streamline contributions, all while maintaining control over their intellectual property. This hybrid model brings the best of both worlds.</p><h4><strong>How to Manage a Successful InnerSource Program</strong></h4><p><strong>InnerSource</strong> is the practice of applying open-source patterns to projects with a limited audience. For example, a company might establish an InnerSource program that mirrors the structure of a typical open-source project, except that it’s only accessible to the employees of that company. In effect, it’s an open-source program behind your company’s firewall.</p><p>An <strong>InnerSource</strong> program offers several benefits beyond traditional closed-source models:</p><ol><li><strong>Internal Visibility</strong>: Developers can access source code, issues, and project plans from other teams, which boosts productivity by allowing them to reuse code and better understand project progress and direction.</li><li><strong>Reduced Friction</strong>: Teams can propose changes to other teams’ projects, like bug fixes or new features. If changes can’t be merged, they have the option to fork the project to meet their needs.</li><li><strong>Standardized Practices</strong>: InnerSource helps standardize processes across teams, making it easier for developers to contribute to different projects even if teams have different workflows. It encourages consistency in how contributions and processes are managed.</li></ol><h4><strong>Set up an InnerSource program on GitHub</strong></h4><p>GitHub repositories can be configured with three levels of <strong>visibility</strong>:</p><ol><li><strong>Public</strong>: Visible to everyone, suitable for open-source projects accessible both internally and externally.</li><li><strong>Internal</strong>: Visible only to members of the enterprise that owns the repository, ideal for <strong>InnerSource</strong> projects within an organization. (Note: Available to GitHub Enterprise customers.)</li><li><strong>Private</strong>: Visible only to the owner and those specifically granted access, suitable for projects with restricted access.</li></ol><p>In addition to visibility, you can set <strong>permissions</strong> at the individual or team level, with five possible levels:</p><ol><li><strong>Read</strong>: For non-code contributors who want to view or discuss the project.</li><li><strong>Triage</strong>: For contributors managing issues and pull requests without write access.</li><li><strong>Write</strong>: For contributors who actively push to the project.</li><li><strong>Maintain</strong>: For project managers who manage the repository but don’t perform sensitive actions.</li><li><strong>Admin</strong>: For full access, including security management and repository deletion.</li></ol><p><strong>1. Make Repositories Discoverable</strong></p><p>Use <strong>clear, descriptive repository names</strong> (e.g., warehouse-api, supply-chain-web)</p><p>Write a <strong>concise project description</strong> (1–2 sentences)</p><p>Add a <strong>license file</strong> to clarify usage rights</p><p>Include a <strong>README.md</strong> file:</p><ul><li>Explain the project’s purpose and goals</li><li>Show examples or screenshots</li><li>Link to live/demo versions if possible</li><li>List prerequisites and setup instructions</li><li>Reference dependencies on other projects</li></ul><p>Use <strong>Markdown</strong> for formatting</p><ul><li>Place README in .github, root, or docs folder</li></ul><p><strong>2. Encourage Contributions</strong></p><p>Create a <strong>CONTRIBUTING.md</strong> file:</p><ul><li>Explain how to submit bug reports, pull requests, etc.</li><li>Outline contribution rules and coding standards</li></ul><p>GitHub will link to this file when users create issues or PRs</p><p>Add a <strong>CODEOWNERS</strong> file:</p><ul><li>Define individuals or teams responsible for reviewing code</li></ul><p><strong>3. Use Templates for Consistency</strong></p><p>Create <strong>issue templates</strong>: .github/ISSUE_TEMPLATE.md</p><ul><li>Pre-fill useful prompts (e.g., steps to reproduce a bug)</li></ul><p>Create <strong>pull request templates</strong>: .github/PULL_REQUEST_TEMPLATE.md</p><ul><li>Guide users to include relevant info in PRs</li></ul><p><strong>4. Define Clear Workflows</strong></p><p>Outline how to handle:</p><ul><li>Branching for features and bug fixes</li><li>Pull request submission and review</li><li>Release and deployment process</li></ul><p>Communicate this clearly in the README or CONTRIBUTING file</p><p>Consider using <strong>GitHub Flow</strong> or similar for guidance</p><p><strong>5. Track Success with Healthy Metrics</strong></p><p>Focus on <strong>team-level</strong>, process-oriented metrics:</p><ul><li>Code review turnaround time</li><li>Average pull request size</li><li>Time from request to first response</li><li>Number of active, unique contributors</li><li>Number of projects reusing shared code</li><li>Cross-team collaboration signals (e.g., @mentions)</li></ul><h3><strong>Module 3:</strong> Maintain a Secure Repository Using GitHub Best Practices</h3><p>Security in software development is no longer an afterthought — it’s a continuous practice that begins the moment you start writing code. A secure development strategy ensures your data, code, and workflows are protected at every step.</p><p><strong>Shift Left: Security Starts Early</strong></p><p>Security shouldn’t wait until deployment. The <strong>“shift left”</strong> approach means integrating security testing early in the development lifecycle — alongside coding, building, and reviewing. This allows teams to catch vulnerabilities sooner, reduce rework, and deliver safer software faster.</p><p><strong>Build a Security-First Culture</strong></p><p>Security is an evolving discipline. Developers and teams must keep learning about secure coding, threat modeling, and compliance. A culture of continuous security education helps prevent both mistakes and misunderstandings.</p><p><strong>Essential GitHub Security Features</strong></p><p>GitHub provides built-in tools that make securing your repositories easier:</p><ul><li><strong>SECURITY.md</strong> — Communicate how to report vulnerabilities responsibly.</li><li><strong>Dependabot Alerts</strong> — Detect and fix vulnerable dependencies automatically.</li><li><strong>Security Advisories</strong> — Privately discuss and publish vulnerability fixes.</li><li><strong>Code Scanning</strong> — Find and resolve security issues directly in your code.</li><li><strong>Secret Scanning &amp; Push Protection</strong> — Prevent accidental leaks of credentials and tokens.</li></ul><p><strong>Keep Sensitive Files Out</strong></p><p>Use <strong>.gitignore</strong> to prevent committing private data or configuration files. Always assume that once data is committed, it’s potentially exposed — even if deleted later.</p><p><strong>Enforce Secure Collaboration</strong></p><p>Protect your critical branches with rules and reviews:</p><ul><li><strong>Branch Protection Rules</strong> — Require builds, linting, or tests before merging.</li><li><strong>Required Reviewers</strong> — Ensure code is reviewed before changes go live.</li><li><strong>CODEOWNERS File</strong> — Assign ownership and accountability for specific parts of your codebase.</li></ul><p><strong>Key Takeaway</strong></p><p>Security isn’t a single feature — it’s a mindset. By shifting left, automating checks, and using GitHub’s built-in tools, teams can make security a natural part of their everyday development flow.</p><h4>Automating Security in GitHub: How to Protect Your Codebase with Minimal Effort</h4><p>In today’s fast-paced software development environment, security is more crucial than ever. With countless external dependencies and the constant need to push new updates, it can be easy to overlook potential vulnerabilities. Fortunately, GitHub provides a suite of automated tools to help you ensure your repositories remain secure, without the manual overhead. In this article, we’ll explore the powerful automated security features GitHub offers, and how you can use them to protect your projects.</p><p><strong>1. Detect and Fix Outdated Dependencies with Security Vulnerabilities</strong></p><p>One of the most significant security risks in modern software projects is outdated dependencies. As your project grows, it becomes harder to track every package’s version and security status. Left unchecked, outdated dependencies can expose your project to known vulnerabilities. Fortunately, GitHub has several features that can help mitigate this risk, allowing you to keep your project safe without constantly monitoring every dependency.</p><p><strong><em>Repository Dependency Graph</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*b7uq4h6o_LgrtZ40AQ61ZQ.png" /></figure><p>Every GitHub repository comes with a <strong>dependency graph</strong> by default. GitHub scans the common package manifests in your project (such as package.json, requirements.txt, etc.) and creates a visual representation of your project’s dependencies. This makes it easier to track what your project relies on, and which dependencies might have security risks.</p><p><strong><em>Dependabot Alerts</em></strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*qyrozl_h2l88wvTZ9qAYSQ.png" /></figure><p>Even with the dependency graph, it can still be overwhelming to keep track of security vulnerabilities across all of your dependencies. This is where <strong>Dependabot alerts</strong> come in. These alerts automatically monitor your dependency graph and cross-reference your project’s packages against known vulnerability lists. When a new risk is detected, you’ll receive an alert directly in your GitHub repository, helping you stay on top of potential threats.</p><p><strong><em>Automated Dependency Updates with Dependabot</em></strong></p><p>When a vulnerability is identified, your team typically needs to update the affected dependency. Instead of manually checking and updating versions, <strong>Dependabot</strong> automates this process. It creates pull requests with the updated versions, which can be reviewed and merged by your team. This ensures that your project always uses the latest secure versions of its dependencies, with minimal manual intervention.</p><p><strong>2. Automated Code Scanning: Catching Vulnerabilities in Your Code</strong></p><p>While dependencies are a common source of vulnerabilities, your actual code might also have security flaws. GitHub’s <strong>automated code scanning</strong> can help find these vulnerabilities, whether they’re new or old.</p><p><strong><em>Why Code Scanning Matters</em></strong></p><p>Code scanning lets you automatically scan your repository for security issues, errors, and potential vulnerabilities. It also helps you prioritize which issues to address first, ensuring that the most critical problems are handled promptly. GitHub integrates <strong>CodeQL</strong>, a query language that allows you to query your code as data, enabling you to detect vulnerabilities efficiently.</p><p>With code scanning, you can:</p><ul><li><strong>Find and triage vulnerabilities</strong> before they become a serious issue.</li><li><strong>Prevent new vulnerabilities</strong> from entering the codebase by catching issues during development.</li><li><strong>Customize scans</strong> using queries created by both the GitHub team and the open-source community.</li></ul><p>You can easily enable automated code scanning from the <strong>Security</strong> tab in your GitHub repository. Once activated, GitHub will run scans every time new code is pushed, keeping your repository secure and up to date.</p><p><strong>3. Secret Scanning: Keeping Your Secrets Safe</strong></p><p>Accidentally committing sensitive information — such as API keys, credentials, or other secrets — into your repository is a common mistake that can have serious security implications. <strong>Secret scanning</strong> helps mitigate this risk by automatically detecting secrets in your code.</p><p><strong><em>How Secret Scanning Works</em></strong></p><p>GitHub’s secret scanning feature automatically searches for known secrets in your repository’s code. This is especially important for public repositories, where anyone can view your code. When a secret is detected, GitHub notifies the service provider that issued the credential (e.g., AWS, Google Cloud, or Stripe), who can then take action to revoke the compromised secret or issue a new one.</p><p>By default, <strong>secret scanning</strong> is enabled for public repositories. For private repositories, repository administrators or organization owners can enable this feature as well. This proactive scanning can save you from costly breaches and secure your application’s integrity.</p><p><strong>Conclusion: GitHub’s Automation Tools Are a Game-Changer for Security</strong></p><p>GitHub’s suite of automated security features — such as <strong>Dependabot alerts</strong>, <strong>code scanning</strong>, and <strong>secret scanning</strong> — make it easier than ever to maintain a secure codebase. By leveraging these tools, you can detect and fix security vulnerabilities in both your dependencies and your own code with minimal effort. Best of all, these automated checks run in the background, freeing up your time to focus on what really matters: developing great software.</p><h3><strong>Module 4:</strong> Introduction to GitHub Administration</h3><p>GitHub administration is the process of managing users, teams, and permissions within an organization to ensure smooth collaboration and strong security. The goal is to keep systems running efficiently while maintaining proper access control and structure.</p><p>GitHub administration operates across <strong>three main levels</strong>: <strong>team</strong>, <strong>organization</strong>, and <strong>enterprise</strong>.</p><p><strong>1. Team-Level Administration</strong></p><p>Teams represent smaller groups within an organization and often mirror the company’s internal structure. They allow more granular control over repository permissions and foster better communication between members.</p><p>At the team level, administrators can:</p><ul><li>Create, rename, or delete teams</li><li>Add or remove members, or sync team membership with an <strong>Identity Provider (IdP)</strong> such as <em>Microsoft Entra ID</em></li><li>Manage outside collaborators (e.g., consultants or contractors)</li><li>Enable or disable team discussions</li><li>Set team visibility and profile images</li><li>Configure <strong>automatic code review assignments</strong> and reminders</li></ul><p><strong>Best Practices:</strong></p><ul><li>Build <strong>nested teams</strong> that reflect your company hierarchy.</li><li>Create <strong>interest- or technology-based teams</strong> (e.g., JavaScript, Data Science) to streamline pull request reviews.</li><li>Use <strong>IdP synchronization</strong> to automate onboarding, permission updates, and offboarding — reducing manual work and errors.</li></ul><p><strong>2. Organization-Level Administration</strong></p><p>Organizations are shared spaces that enable users to collaborate across multiple projects at once. Owners and administrators have advanced control over user access, security, and overall structure.</p><p>At the organization level, owners can:</p><ul><li>Invite or remove members</li><li>Create teams and assign team maintainers</li><li>Manage outside collaborators and repository access levels</li><li>Configure security and billing</li><li>Use custom scripts for reporting or large-scale migrations</li></ul><p><strong>Recommendation:</strong> <br>Try to maintain a <strong>single organization</strong> for all users and repositories. Managing multiple organizations adds complexity, setup time, and potential for misconfiguration.</p><p><strong>3. Enterprise-Level Administration</strong></p><p>Enterprise accounts (GitHub Enterprise Cloud or Enterprise Server) allow centralized management of multiple organizations, policies, and billing structures.</p><p>Enterprise-level administrators can:</p><ul><li>Enable <strong>SAML (Security Assertion Markup Language)</strong> Single Sign-On (SSO) to link external IdP identities with GitHub accounts</li><li>Add or remove organizations from the enterprise</li><li>Manage <strong>central billing</strong> for all organizations</li><li>Define enterprise-wide policies for repositories, projects, teams, and security</li><li>Apply large-scale configuration changes or data migrations</li><li>Integrate internal systems with <strong>GitHub.com</strong> using GitHub Connect</li></ul><h4><strong>Understanding SAML, IdP, and SP</strong></h4><p>To better understand how authentication and access control work in GitHub Enterprise, let’s break down a few key terms:</p><p><strong>🔸 SAML (Security Assertion Markup Language)</strong></p><p>SAML is an <strong>XML-based standard</strong> used for securely sharing authentication and authorization data between two systems — usually an <strong>Identity Provider (IdP)</strong> and a <strong>Service Provider (SP)</strong>. <br>It enables <strong>Single Sign-On (SSO)</strong> — letting users log in once and access multiple apps without re-entering their credentials.</p><p><strong>🔸 Identity Provider (IdP)</strong></p><p>An <strong>IdP</strong> is a system that verifies user identities. Examples include <strong>Microsoft Entra ID</strong>, <strong>Okta</strong>, or <strong>Google Workspace</strong>. <br>When a user logs in, the IdP authenticates them and sends a <strong>SAML assertion</strong> (a secure message confirming the user’s identity) to GitHub.</p><p><strong>🔸 Service Provider (SP)</strong></p><p>The <strong>SP</strong> is the application that the user wants to access — in this case, <strong>GitHub</strong>. <br>GitHub trusts the IdP’s authentication, receives the SAML assertion, and grants access to the user without requiring another login.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*eYi2GSwVZkwWEPhS2vpzOQ.jpeg" /></figure><p><strong>In Summary</strong></p><p>GitHub administration ensures efficient collaboration and security at every level:</p><ul><li><strong>Team level</strong> — manage collaboration and permissions</li><li><strong>Organization level</strong> — control access, structure, and governance</li><li><strong>Enterprise level</strong> — enforce centralized security and integration policies</li></ul><p>When managed effectively, GitHub becomes not just a development platform, but a <strong>cohesive ecosystem</strong> for collaboration, compliance, and innovation.</p><h3><strong>How GitHub Authentication Works: A Quick Guide for Teams and Admins</strong></h3><p>When managing a GitHub organization or enterprise, one of the most important administrative tasks is controlling how users authenticate to access your repositories. GitHub provides several secure authentication options — each designed for different use cases and security needs. Let’s break them down.</p><p><strong>Authentication Options</strong></p><p><strong>1. Personal Access Tokens (PATs)</strong></p><p>GitHub no longer supports passwords for Git or API operations. Instead, users can generate <strong>Personal Access Tokens</strong> as a more secure alternative. <br>Each token can be scoped to specific repositories or organizations, limiting access to only what’s necessary. When using the command line, users enter the token instead of a password.</p><p><strong>2. SSH Keys</strong></p><p>SSH keys are a secure and convenient way to authenticate without entering credentials every time. <br>Users generate an SSH key pair, add the <strong>public key</strong> to GitHub, and keep the <strong>private key</strong> on their machine. For organizations using SAML SSO, SSH certificates can also be used to streamline secure access.</p><p><strong>3. Deploy Keys</strong></p><p>Deploy keys are special SSH keys that grant access to a <strong>single repository</strong> — ideal for automated deployments or CI/CD systems. <br>The public key is added directly to the repository (not tied to a user account), and permissions can be configured as <strong>read-only</strong> or <strong>read-write</strong>.</p><p><strong>Added Security Layers</strong></p><p><strong>4. Two-Factor Authentication (2FA)</strong></p><p>To strengthen account security, GitHub supports multiple forms of 2FA, including:</p><ul><li>Authenticator apps (Google Authenticator, Authy, etc.)</li><li>Hardware security keys (YubiKey, Titan)</li><li>Passkeys (passwordless login)</li><li>SMS codes (less secure, not recommended)</li></ul><p>Organization and enterprise admins can <strong>enforce 2FA</strong> for all members and collaborators, reducing the risk of unauthorized access.</p><p><strong>5. SAML Single Sign-On (SSO)</strong></p><p>For enterprises using centralized identity management, <strong>SAML SSO</strong> lets users authenticate through an Identity Provider (IdP) like:</p><ul><li>Microsoft Entra ID (Azure AD)</li><li>Okta</li><li>OneLogin</li><li>PingOne</li><li>AD FS</li></ul><p>This setup gives admins complete control over who can access repositories and resources while keeping credentials managed in one place.</p><p><strong>6. LDAP Integration (GitHub Enterprise Server)</strong></p><p>For on-premise environments, <strong>LDAP</strong> integration allows GitHub Enterprise Server to authenticate users directly against corporate directories such as:</p><ul><li>Active Directory</li><li>OpenLDAP</li><li>Oracle Directory Server</li></ul><p>This ensures seamless access control using your existing enterprise identity systems.</p><p><strong>Key Takeaway</strong></p><p>GitHub offers flexible, layered authentication options that balance convenience and security. <br>From tokens and SSH keys to SAML and 2FA, admins can tailor authentication methods to their organization’s needs — keeping code, data, and users safe.</p><blockquote><em>Pro Tip: Always enforce 2FA for all members and use tokens or SSH keys instead of passwords for Git operations.</em></blockquote><h3><strong>Understanding GitHub Organizations and Permissions: The Complete Guide for Teams and Admins</strong></h3><p>As your development team grows, managing access and permissions on GitHub becomes essential. GitHub’s permission structure is designed to give the right people the right level of access — while keeping your repositories secure and well-organized.</p><p>Let’s break down how permissions work across repositories, teams, organizations, and enterprises.</p><p><strong>Repository Permissions</strong></p><p>Each GitHub repository has <strong>five standard permission levels</strong>, each granting progressively more control:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*WRovlixfL-5H4dNviM3zLg.jpeg" /></figure><blockquote><em>Tip: Always apply the principle of least privilege — grant users only what they need to do their job.</em></blockquote><p>Admins on <strong>GitHub Enterprise</strong> can also create <strong>custom roles</strong> by extending these base roles with specific permissions.</p><p><strong>Forking Repositories</strong></p><p><strong>Forking</strong> allows users to create their own copy of a repository under their account. <br>It’s perfect for experimenting, contributing to open source, or making changes without affecting the original project.</p><p><strong>Fork management options for admins:</strong></p><ul><li><strong>Public repositories:</strong> Always forkable.</li><li><strong>Private repositories:</strong> Forking can be disabled or limited to organization members.</li><li><strong>Internal repositories:</strong> Can only be forked within the same enterprise.</li></ul><p><em>To update fork permissions:</em> <br>Navigate to <strong>Settings → Member privileges → Repository forking</strong> in your organization dashboard.</p><p><strong>Repository Insights</strong></p><p>GitHub’s <strong>Insights tab</strong> gives valuable visibility into repository activity and health:</p><ul><li><strong>Contributors:</strong> Track commits, additions, and deletions over time.</li><li><strong>Traffic:</strong> See visits, views, and referrers.</li><li><strong>Commits:</strong> Monitor commit frequency.</li><li><strong>Dependency Graph:</strong> Identify potential security vulnerabilities.</li></ul><p><em>Use insights to monitor contributions, track engagement, and improve security.</em></p><p><strong>Ways Users Get Repository Access</strong></p><p>A user’s effective access is determined by <strong>the highest level of permission</strong> they receive through any of these methods:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*9fjWUYM61K2JIEr1KDEegQ.jpeg" /></figure><p><strong>Auditing Access:</strong></p><ul><li>Go to <strong>Settings → Manage Access</strong> to review users and teams.</li><li>Use the <strong>Organization Audit Log</strong> or <strong>Enterprise Audit Log</strong> for deeper tracking.</li><li>Automate monitoring with the <strong>GitHub REST or GraphQL API</strong>.</li></ul><p><strong>Team Permissions</strong></p><p>Teams make permission management scalable and structured. <br>You can group users by <strong>department</strong>, <strong>project</strong>, or <strong>role</strong> — and assign permissions to the entire team at once.</p><p>Team members inherit access from their parent teams, allowing nested control.</p><p><strong>Team Roles</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*KmBH6a0Dx1oeIyVOoop7dQ.jpeg" /></figure><p>Maintainers can also:</p><ul><li>Add or remove team members</li><li>Edit team details</li><li>Manage code review assignments</li><li>Control repository access for their team</li></ul><p><strong>Best Practices for GitHub Permission Management</strong></p><ol><li><strong>Follow the Principle of Least Privilege</strong> — Avoid giving more access than necessary.</li><li><strong>Audit Regularly</strong> — Check who has admin or write access to critical repositories.</li><li><strong>Use Teams for Scalability</strong> — Manage groups, not individuals.</li><li><strong>Enforce Branch Protections</strong> — Require reviews and CI checks before merging.</li><li><strong>Monitor Activity</strong> — Use Insights and Audit Logs for transparency and security.</li></ol><p><strong>Takeaway</strong></p><p>GitHub’s layered permission system — spanning repositories, teams, organizations, and enterprises — makes it easier to manage access at scale while maintaining tight security. <br>Whether you’re running an open-source project or managing hundreds of developers, understanding these controls ensures smooth collaboration and robust governance.</p><blockquote><em>Pro Tip: Combine GitHub’s permissions with 2FA or SAML SSO for maximum protection and accountability across your organization.</em></blockquote><h3><strong>Managing Enterprise Access, Permissions, and Governance on GitHub</strong></h3><p>As teams scale, managing access and governance across multiple repositories becomes critical. GitHub provides structured permission models to help enterprises balance collaboration, control, and security.</p><p><strong>Organization Permissions</strong></p><p>GitHub organizations centralize collaboration and define who can do what.</p><p><strong>Main roles:</strong></p><ul><li><strong>Owner:</strong> Full control, including member management.</li><li><strong>Member:</strong> Can create and manage repositories and teams.</li><li><strong>Moderator:</strong> Manages discussions and contributor interactions.</li><li><strong>Billing Manager:</strong> Handles billing details.</li><li><strong>Security Manager:</strong> Oversees security alerts and policies.</li><li><strong>Outside Collaborator:</strong> Limited access to specific repositories.</li></ul><p>Admins can set <strong>default member permissions</strong>, often giving <em>read-only</em> access by default and elevating privileges as needed.</p><p><strong>Enterprise Permissions</strong></p><p>At the enterprise level, administrators manage policies across multiple organizations.</p><p><strong>Enterprise roles:</strong></p><ul><li><strong>Owner:</strong> Full administrative control and policy enforcement.</li><li><strong>Member:</strong> Standard collaboration rights.</li><li><strong>Billing Manager:</strong> Manages enterprise billing.</li><li><strong>Guest Collaborator:</strong> Limited access (for Managed Users).</li></ul><p>Enterprises can also define <strong>default repository permissions</strong> and streamline governance through <strong>nested teams, automation, and auditing</strong>.</p><p><strong>Structuring Your Enterprise</strong></p><p><strong>Single Organization:</strong> Easier to manage and consistent, but less flexible and riskier if compromised. <br><strong>Multiple Organizations:</strong> More secure and customizable, but introduces complexity and administrative overhead.</p><p>Most large enterprises use <strong>multiple organizations</strong> for better isolation and scalability.</p><p><strong>Default Read vs. Default Write</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*ilGWMQzVCo99790VEOgoqQ.png" /></figure><p><strong>Active Directory (AD) Sync &amp; Automation</strong></p><p>Syncing GitHub with <strong>Active Directory</strong> centralizes user management, automates onboarding, and ensures consistent roles.</p><p>Automation and scripting improve scalability — use modular, reusable code with logging, testing, and version control to keep permissions aligned across organizations.</p><p><strong>Key Takeaway</strong></p><p>Enterprise governance on GitHub is about <strong>balance</strong>: combine structured permissions, least-privilege access, AD integration, and automation to maintain both agility and control.</p><p>With the right setup, GitHub becomes a secure, scalable platform for enterprise collaboration.</p><h3><strong>Module 5:</strong> Authenticate and Authorize User Identities on GitHub</h3><p><strong>Authentication</strong> is the first gate to any secure development ecosystem — and in <strong>GitHub Enterprise</strong>, it’s the cornerstone of safeguarding your organization’s code, data, and workflows. Balancing usability with strong security practices ensures developers can move fast <em>without</em> compromising protection.</p><p><strong>Modern Authentication in GitHub</strong></p><p>GitHub offers several modern, secure authentication methods that integrate smoothly with enterprise identity systems:</p><ul><li><strong>Passkeys &amp; WebAuthn:</strong> <br>Passwordless, phishing-resistant logins tied to a user’s physical device or biometric factors like fingerprint or face ID. These enhance both security and user experience.</li><li><strong>GitHub Mobile for 2FA:</strong> <br>Push notifications enable quick, secure authentication without disrupting developer workflows.</li></ul><p><strong>OAuth and GitHub Apps</strong></p><ul><li><strong>OAuth Apps</strong> leverage GitHub’s OAuth 2.0 flow to grant scoped access to third-party applications.</li><li><strong>GitHub Apps</strong> authenticate at the installation level with fine-grained permissions — perfect for automation and CI/CD pipelines.</li></ul><p><strong>Enterprise Managed Users (EMU)</strong></p><p>In <strong>GitHub Enterprise Cloud</strong>, EMUs enforce authentication <em>only</em> through your organization’s Identity Provider (IdP). <br>This ensures:</p><ul><li>Centralized identity control</li><li>Enforced credential policies</li><li>Strict access boundaries</li></ul><p><strong>SAML Single Sign-On (SSO)</strong></p><p><strong>SAML SSO</strong> is the backbone of enterprise-grade authentication. It connects your IdP (like Okta, Microsoft Entra ID, or PingOne) with GitHub, allowing users to sign in once across multiple services securely. <br>Admins can manage:</p><ul><li>Role-based access</li><li>Activity monitoring and auditing</li><li>Least-privilege permissioning</li></ul><p><strong>Access and Authorization Controls</strong></p><p>GitHub’s layered authorization model helps enterprises enforce robust security policies:</p><ul><li><strong>Fine-Grained Personal Access Tokens (PATs):</strong> Scoped, expirable, and auditable tokens replacing classic PATs.</li><li><strong>Custom Repository Roles:</strong> Enables tailored access and least-privilege configurations.</li><li><strong>Security Policies:</strong> Mandatory 2FA, IP allowlists, and OAuth app restrictions.</li></ul><p><strong>Organization and Enterprise Governance</strong></p><p><strong>Organization-level</strong> controls include default roles, team-based access, and the management of external collaborators.</p><p><strong>Enterprise-level</strong> governance includes:</p><ul><li>Centralized SAML enforcement.</li><li>IdP-based login restrictions.</li><li>Global policy enforcement via <strong>GitHub Enterprise Cloud</strong>.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*5zKZ_hEKwoG_paHymxrDVw.png" /></figure><p><strong>User Authentication</strong></p><p>When it comes to user authentication, security should be the number one consideration that comes to mind. Strong security is essential. It seems like every month or so, a company reports a data breach. Credentials are stolen because of inefficient security processes, or simply because of a lack of up-to-date security features within the company. Establishing secure user authentication can be a difficult task if user adoption requires long and frustrating steps to authenticate.</p><p>GitHub Enterprise supports two recommended methods for secure user authentication:</p><ul><li><strong>SAML Single Sign-On(SSO)</strong></li><li><strong>Two-Factor Authentication(2FA)</strong></li></ul><p><strong>SAML Single Sign-On(SSO)</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/873/1*wSlrs_sMuKnLPpvuyzxEiQ.png" /></figure><blockquote><strong><em>GitHub removes only organization members who fail to authenticate. Enterprise members remain until they next access the resource.</em></strong></blockquote><p><strong>Step-by-Step: Enabling and Enforcing SAML SSO</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*QZAVOQv98VjSiDoWVg0jmA.png" /></figure><p><strong>Two-Factor Authentication (2FA)</strong></p><p>2FA adds a second verification step beyond username and password. You can require 2FA for organization members, outside collaborators, and billing managers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*5JvZY633bK0OSw-nUzTZKA.png" /></figure><h3><strong>User Authorization in GitHub Enterprise</strong></h3><p>After users <strong>authenticate</strong> through your Identity Provider (IdP) with <strong>SAML Single Sign-On (SSO)</strong>, the next layer of protection is <strong>authorization</strong> — deciding what those users (and their tools) can access within your organization.</p><p><strong>From Authentication to Authorization</strong></p><p>While <strong>authentication</strong> verifies <em>who</em> a user is, <strong>authorization</strong> defines <em>what</em> they can do. <br>In GitHub, this means granting access to organization resources through secure tools such as:</p><ul><li><strong>Personal Access Tokens (PATs)</strong></li><li><strong>SSH Keys</strong></li><li><strong>OAuth Apps</strong></li></ul><p>Security Assertion Markup Language (SAML) Single Sign-On (SSO) enables <strong>enterprise and organization owners</strong> to centrally control and manage user access to <strong>GitHub resources such as repositories, issues, pull requests, and other collaboration tools.</strong></p><p><strong>Automating Authorization with SAML SSO + SCIM</strong></p><p>To streamline and secure access control, GitHub Enterprise supports integration between <strong>SAML SSO</strong> and <strong>SCIM (System for Cross-domain Identity Management).</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*cFZ3vygzEMZGcjBmAwPyaA.png" /></figure><p><strong>Why It Matters</strong></p><p>Integrating SCIM with SAML SSO ensures:</p><ul><li><strong>Automatic onboarding</strong> of new employees</li><li><strong>Automatic removal</strong> of departing users</li><li><strong>Reduced manual errors and overhead</strong></li><li><strong>Immediate token revocation</strong>, minimizing security risk</li></ul><p>Without SCIM, enterprise admins must manually manage user removal and token cleanup — a time-consuming and error-prone process.</p><p><strong>Managing SSH Keys and Personal Access Tokens (PATs) with SAML SSO in GitHub Enterprise</strong></p><p>In an enterprise environment, managing <strong>identities and credentials</strong> isn’t just about signing in — it’s about ensuring that every key, token, and permission reflects your organization’s identity and access policies. <br>That’s where <strong>SAML SSO</strong> and <strong>SCIM</strong> come together to automate and secure GitHub access across users, systems, and integrations.</p><p><strong>Credential Management: SSH Keys and PATs</strong></p><p>Even with centralized SSO, <strong>developers and systems</strong> still rely on <strong>Personal Access Tokens (PATs)</strong> and <strong>SSH keys</strong> to connect securely to GitHub APIs or Git operations.</p><ul><li>These credentials are <strong>authorized</strong> and <strong>auditable</strong>, and each is securely <strong>linked to a verified SAML SSO identity</strong>.</li><li>Admins can <strong>review</strong>, <strong>revoke</strong>, or <strong>rotate</strong> these credentials anytime through organization security settings.</li><li>For onboarding, new users can register via: <br>👉 <a href="https://github.com/orgs/ORGANIZATION/sso/sign_up">https://github.com/orgs/ORGANIZATION/sso/sign_up</a> <br>This link can be displayed in your IdP dashboard to simplify user setup.</li></ul><p><strong>SCIM Integration with GitHub Enterprise Cloud</strong></p><p>SCIM simplifies identity management by supporting both <strong>native</strong> and <strong>custom</strong> integrations.</p><p><strong><em>Supported Providers</em></strong></p><ul><li>Okta</li><li>Microsoft Entra ID</li><li>OneLogin</li><li>Ping Identity</li><li>Google Workspace</li></ul><p>These providers offer <strong>native GitHub integration</strong>, ensuring reliable provisioning and minimal setup effort.</p><p><strong><em>Custom SCIM Integrations</em></strong></p><p>If your IdP isn’t natively supported, GitHub’s <strong>SCIM 2.0 API</strong> lets you build your own integration. <br>For example:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/810/1*rZobKQGAlwxy_hDTL8ggzw.png" /></figure><p><strong>SCIM vs. Manual User Management</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*ycXnUazHo3cTL7Kz5SnWRw.png" /></figure><p><strong>Comparing IdP Integration Paths</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*rZe5kF_LaCV65zY4pZIWvw.png" /></figure><p><strong>GitHub Membership Considerations</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*9FLYttri1Lj6SghyV1tQdg.jpeg" /></figure><h3><strong>Team Synchronization in GitHub Enterprise: Automating Access the Smart Way</strong></h3><p>Managing user and team access across large development organizations can quickly become messy — especially when headcount and roles are constantly changing. <br>GitHub’s <strong>Team Synchronization</strong> feature bridges this gap by connecting your <strong>Identity Provider (IdP)</strong>, like <strong>Microsoft Entra ID (Azure AD)</strong> or <strong>Okta</strong>, directly with your GitHub teams.</p><p>When enabled, <strong>team sync</strong> automatically updates GitHub team memberships based on group changes in your IdP — eliminating manual updates, scripts, and the risk of access drift.</p><p><strong>Team Synchronization vs. SCIM for GHES</strong></p><p>In GitHub Enterprise Server (GHES), managing user access and team memberships can be achieved through various methods, including team synchronization and System for Cross-domain Identity Management (SCIM). Understanding these methods is essential for effective administration.</p><p><strong>What Team Synchronization Does</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*dXamf64VgJ8lj4JTcutaqw.png" /></figure><blockquote><strong>Team Sync doesn’t create new GitHub accounts — users must already be organization members.</strong></blockquote><p><strong>Differences Between Team Sync and Group SCIM</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*BiQKcsOzTXIlBW-W_epOIw.png" /></figure><p><strong>Enabling and Managing Team Synchronization</strong></p><p><strong>To enable:</strong></p><ol><li>Ensure <strong>SAML SSO</strong> and <strong>SCIM</strong> are active in your IdP.</li><li>Map GitHub teams to IdP groups via the <strong>GitHub UI or API</strong>.</li><li>Group membership changes in your IdP will sync automatically.</li></ol><p><strong>Supported IdPs:</strong></p><ul><li>Microsoft Entra ID (Azure AD)</li><li>Okta</li></ul><blockquote><strong>Okta Requirements:</strong> SAML SSO, SCIM, tenant URL, and an SSWS token with read-only admin access.</blockquote><p><strong>Team Sync Usage Limits</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*roID3ZVnRLZX3LsXh2EwjA.png" /></figure><p><strong>Choosing the Right Approach</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*Ip8u_kfYkG92a-o0zWbPuw.png" /></figure><h3><strong>Module 6:</strong> Manage Repository Changes Using Pull Requests on GitHub</h3><p>In GitHub, <strong>branches</strong> are isolated workspaces where developers can make changes without affecting the main project. They allow you to work on features, fix bugs, or experiment safely. However, at some point, these separate branches need to be combined into a common branch, typically the main branch. This is where <strong>pull requests (PRs)</strong> come in.</p><p>A <strong>pull request</strong> is a way to propose changes from one branch into another while allowing for review and discussion. It compares two branches:</p><ul><li><strong>Compare branch:</strong> The branch containing the changes made by the developer.</li><li><strong>Base branch:</strong> The branch where the changes are intended to be merged, usually main.</li></ul><p>Pull requests serve as a tool for collaboration, letting team members review code, leave comments, and ensure high-quality updates before merging.</p><p><strong>Merging Pull Requests</strong></p><p>GitHub provides multiple merge options:</p><ul><li><strong>Merge commit:</strong> Combines all commits while keeping individual commit history.</li><li><strong>Squash and merge:</strong> Combines all commits into a single commit for a cleaner history.</li><li><strong>Rebase and merge:</strong> Reapplies commits on top of the base branch, creating a linear history without a merge commit.</li></ul><p>After merging, the compare branch can be deleted to keep the repository organized.</p><p><strong>GitHub Pull Request Merge Options</strong></p><p><strong>Branches Setup</strong></p><p>main: A — -B — -E <br>feature: C — -D</p><ul><li>main = base branch</li><li>feature = compare branch</li><li>A, B, E = commits on main</li><li>C, D = commits on feature</li></ul><p><strong>Merge Commit</strong></p><ul><li>Combines all feature branch commits into main.</li><li>Keeps all individual commits + adds a <strong>merge commit</strong>.</li></ul><p>main: A — -B — -E — — — — -M <br>feature: C — -D /</p><ul><li>M = merge commit</li><li>History shows all commits and the merge itself.</li></ul><p><strong>Squash and Merge</strong></p><ul><li>Combines all feature branch commits into <strong>one commit</strong> before merging.</li><li>Keeps history clean, no clutter from multiple small commits.</li></ul><p>main: A — -B — -E — -S <br>feature: C — -D</p><ul><li>S = single squash commit</li></ul><p><strong>Rebase and Merge</strong></p><ul><li>Reapplies feature commits <strong>on top of main</strong>.</li><li>Maintains <strong>linear history</strong>, no merge commit.</li></ul><p>main: A — -B — -E — -C’ — -D’ <br>feature: C — -D</p><ul><li>C’ and D’ = new commits with same changes</li><li>Clean, sequential history for easier tracking.</li></ul><p><strong>Advanced Features</strong></p><ul><li><strong>Requesting reviewers:</strong> Assign specific collaborators to review the PR.</li><li><strong>Branch protection rules:</strong> Some repositories require approvals, passing CI checks, or other conditions before merging.</li><li><strong>Status checks/CI:</strong> Automated tests or checks may run on PRs to ensure quality and security.</li></ul><h3><strong>Module 7:</strong> Search and Organize Repository History on GitHub</h3><p><strong>Searching the Repository</strong></p><p><strong>Global Search:</strong></p><ul><li>Searches all of GitHub (repositories, issues, PRs, users, Marketplace).</li><li>Use advanced search syntax for precise queries.</li><li>Example: sidebar repo:myorg/myrepo → finds “sidebar” mentions in a specific repo.</li></ul><p><strong>Context Search:</strong></p><ul><li>Scoped to a specific tab (Issues, Pull Requests, Code).</li><li>Provides type-specific filters: author, labels, projects, etc.</li><li>Preferred for repository-specific queries.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/1*QB5n6Rq6-zmYKHIEhZpGKQ.jpeg" /></figure><p><strong>Using Milestones</strong></p><p>Group issues and PRs into shared goals (sprints, releases, phases).</p><p>Track progress automatically (X of Y issues complete).</p><p><strong>Creating Milestone:</strong></p><ul><li>Go to <strong>Issues → Milestones → New milestone</strong></li><li>Add title, description, optional due date</li><li>Assign milestone to issues or PRs</li></ul><p><strong>Search Example:</strong> is:open is:pr milestone:”Release v1.0&quot;</p><p><strong>Using Labels</strong></p><ul><li>Metadata for categorizing issues/PRs (bug, feature, priority).</li><li>Example filter: is:open is:issue label:bug</li><li>Combine with other filters: is:pr label:”ready for review” author:@me</li></ul><p><strong>Using Git Blame</strong></p><ul><li>Shows <strong>who changed what and when</strong> in a file.</li><li>Helps find the right contributor to consult for a bug or feature.</li><li>GitHub extends this with a user-friendly interface.</li></ul><p><strong>Cross-Linking</strong></p><ul><li>Link issues, commits, PRs for better context.</li><li>Autolink syntax: Duplicate of #8 automatically links issue #8.</li><li>Commits auto-link with first 7+ characters of ID.</li></ul><p><strong>Saved Replies</strong></p><ul><li>Prewritten comments for consistent responses.</li><li>Useful for maintainers: FAQ answers, instructions.</li><li>Can be inserted during issue or PR discussion.</li></ul><p><strong>Issue Templates</strong></p><ul><li>Structured forms for new issues (bug reports, feature requests).</li><li>Ensure contributors provide all necessary info upfront.</li><li>Better than saved replies for <strong>collecting structured info</strong>.</li></ul><p><strong>Assignees</strong></p><ul><li>Assign one or more users to indicate responsibility</li><li>Use assignee: filter in searches: is:open is:issue assignee:@me.</li></ul><h3><strong>Module 8:</strong> Using GitHub Copilot with Python</h3><p>GitHub Copilot is an AI-powered coding assistant integrated into your IDE, designed to help developers write code faster and more efficiently. It generates code suggestions based on natural language prompts, allowing you to quickly implement functions, syntax, or entire blocks of code without constantly referring to documentation.</p><p><strong>How It Works:</strong></p><ul><li><strong>Natural Language Prompts</strong>: You type a comment or instruction (e.g., # Create a web API using FastAPI), and Copilot generates corresponding code.</li><li><strong>Context-Aware</strong>: Copilot understands your code context and offers relevant suggestions.</li><li><strong>Suggestions</strong>: Code suggestions appear in gray. You can accept them by pressing <strong>Tab</strong> or cycle through multiple options with <strong>Ctrl + Enter</strong>.</li></ul><p><strong>Key Benefits:</strong></p><ul><li><strong>Boosts Productivity</strong>: Reduces time spent on boilerplate code and syntax, letting you focus on complex tasks.</li><li><strong>Improves Code Quality</strong>: Suggests clean, efficient, and consistent code based on best practices.</li><li><strong>Multi-Language Support</strong>: Works with Python, JavaScript, Go, Ruby, and more, along with various frameworks like FastAPI, Django, and React.</li><li><strong>Assists with Documentation</strong>: Helps generate docstrings and comments, keeping your code well-documented.</li><li><strong>Learn New Tools</strong>: Copilot aids in exploring and working with unfamiliar libraries or frameworks by suggesting relevant code snippets.</li></ul><p>In short, GitHub Copilot accelerates your development process, making coding smarter and faster by generating useful code suggestions directly within your IDE.</p><p><strong>Using GitHub Copilot with Python</strong></p><p>GitHub Copilot isn’t just useful when starting a new project — it can also help you maintain and enhance existing codebases. Whether you’re fixing bugs, adding features, or refactoring code, Copilot and <strong>GitHub Copilot Chat</strong> can make development faster and smoother by assisting directly within your coding environment.</p><p><strong>Developing with GitHub Copilot</strong></p><p>As projects evolve, developers need to keep their code updated, efficient, and functional. GitHub Copilot helps by suggesting relevant code snippets, testing ideas, and even generating new functionality. With <strong>GitHub Copilot Chat</strong>, you can ask natural language questions about your code and get clear, context-aware answers right in your IDE.</p><p><strong>Prompt Engineering</strong></p><p>To get the best results from Copilot, crafting effective prompts is essential. A <strong>prompt</strong> is an instruction or comment that tells Copilot what you want it to do. The quality and clarity of your prompt directly impact the accuracy of Copilot’s output.</p><p>For example:</p><p><em># Create an API endpoint</em></p><p>This prompt is vague and could produce unpredictable results. A better prompt is:</p><p><em># Create an API endpoint using the FastAPI framework that accepts a JSON payload in a POST request</em></p><p>This version is specific, giving Copilot clear direction and context. You can also provide additional details using <strong>comments</strong>, <strong>code examples</strong>, or <strong>Copilot Chat</strong> for richer suggestions.</p><p><strong>Best Practices for Using Copilot</strong></p><p>To get the most from GitHub Copilot, follow these best practices:</p><ol><li><strong>Start simple</strong> — Begin with a short prompt, then refine or expand it as needed.</li></ol><p>Example:</p><ul><li>Start with: <em>create an HTML form with a text field and button</em></li><li>Then expand: <em>add an event listener to send a POST request to /generate and display the response in a div with id “result”.</em></li></ul><p><strong>2. Cycle through suggestions</strong> — Use <strong>Ctrl + Enter</strong> (or <strong>Cmd + Enter</strong> on Mac) to view multiple suggestions and choose the best one.</p><p><strong>3. Reword or guide Copilot</strong> — If suggestions aren’t accurate, tweak your prompt or start typing code to let Copilot autocomplete intelligently.</p><p><strong>4. Use context effectively</strong> — Copilot considers open files in your editor when generating suggestions. To include other files or project-wide context, open them in your IDE or use @workspace in Copilot Chat.</p><h3>Final Thoughts</h3><p>With the completion of these eight modules, this second part concludes my GitHub Foundations Certification notes. In this section, we explored more advanced and practical topics, such as contributing to open-source projects, managing InnerSource programs, securing repositories, administering GitHub environments, and collaborating effectively through pull requests. We also looked into identity management, repository history, and using GitHub Copilot with Python to improve developer productivity.</p><p>Preparing for this certification helped me better understand not only GitHub’s features but also the best practices behind collaboration, security, and maintainability in real-world projects. The exam focuses heavily on concepts and workflows that are commonly used in modern software development teams, making it a valuable learning experience even beyond the certification itself.</p><p>I hope these notes help you feel more confident while preparing for the GitHub Foundations exam or while working with GitHub in your daily projects. Whether you are just starting out or looking to strengthen your foundational knowledge, mastering these topics will make your GitHub experience much more effective.</p><p>If you found this article helpful, feel free to <strong>clap</strong>, <strong>leave a comment</strong>, or <strong>share your own exam experience</strong>. Good luck with your GitHub Foundations journey — and happy coding! 🚀</p><h4>Resources</h4><p><a href="https://learn.microsoft.com/en-us/credentials/certifications/github-foundations/?practice-assessment-type=certification">GitHub Foundations - Certifications</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eb8651c4c573" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[GitHub Foundations Certification Part-1]]></title>
            <link>https://medium.com/@suleakturk/github-foundations-certification-part-1-9a9798cdb9e0?source=rss-4381f97e14d2------2</link>
            <guid isPermaLink="false">https://medium.com/p/9a9798cdb9e0</guid>
            <category><![CDATA[github]]></category>
            <category><![CDATA[github-foundations]]></category>
            <category><![CDATA[version-control]]></category>
            <dc:creator><![CDATA[Sule Akturk]]></dc:creator>
            <pubDate>Wed, 10 Dec 2025 11:41:51 GMT</pubDate>
            <atom:updated>2025-12-10T11:41:51.714Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong>GitHub Foundations Certification</strong></h3><p>GitHub has become an essential tool in modern software development workflows. The <strong>GitHub Foundations Certification</strong> is designed to validate fundamental knowledge and awareness of the GitHub ecosystem.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*L1Wzatw3Irofg2oUT3mAuA.png" /></figure><p>I took this exam and<strong> </strong>successfully passed it,<strong> </strong>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 <strong>Microsoft GitHub Foundations training</strong>.</p><p><a href="https://learn.microsoft.com/en-us/credentials/certifications/github-foundations/?practice-assessment-type=certification">GitHub Foundations - Certifications</a></p><p>To keep the material structured and easy to follow, I divided my notes into <strong>two parts</strong>.<br>In this article, the topics covered are structured as follows:</p><ul><li><strong>Module 1:</strong> Introduction to Git</li><li><strong>Module 2:</strong> Introduction to GitHub</li><li><strong>Module 3:</strong> Introduction to GitHub Products</li><li><strong>Module 4:</strong> Configure Code Scanning on GitHub</li><li><strong>Module 5:</strong> GitHub Copilot</li><li><strong>Module 6:</strong> Code with GitHub Codespaces</li><li><strong>Module 7:</strong> Manage Your Work with GitHub Projects</li><li><strong>Module 8:</strong> Communicate Effectively on GitHub Using Markdown</li></ul><h3>Module 1: Introduction to Git</h3><p>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 <strong>version control system (VCS)</strong> records every modification made to a set of files, allowing developers to review history, revert to previous states, and collaborate safely on shared codebases.</p><p>By using version control, developers can confidently experiment with new features or fixes without risking the stability of the main project.</p><h4>What Does Version Control Provide?</h4><p>Version control systems offer several key benefits:</p><ul><li><strong>Change Tracking:</strong> Monitor what changes were made, when they occurred, and who made them.</li><li><strong>Collaboration:</strong> Enable multiple contributors to work on the same project simultaneously without conflicts.</li><li><strong>Branching and Merging:</strong> Support independent lines of development — such as feature work or bug fixes — that can later be merged back into the main codebase.</li><li><strong>Tags and Releases:</strong> Allow specific commits to be labeled as milestones, such as official releases or stable versions.</li></ul><h4>Git: The Most Widely Used Version Control System</h4><p>Among the available version control tools, <strong>Git</strong> stands out as the most widely adopted. Created by <strong>Linus Torvalds</strong>, the creator of Linux, Git is fast, open-source, and highly scalable. It uses a <strong>distributed architecture</strong>, meaning every contributor has a complete copy of the project’s history on their local machine.</p><p>This decentralized model increases reliability, reduces dependency on a central server, and enables developers to work offline.</p><h4>Common Git Terminology</h4><p>To better understand Git, it is helpful to be familiar with the following core concepts:</p><ul><li><strong>Repository (repo):</strong> A directory that contains the project files along with their full version history.</li><li><strong>Commit:</strong> A snapshot that records changes made to the repository.</li><li><strong>Branch:</strong> A separate line of development used for new features, experiments, or fixes.</li><li><strong>Push / Pull:</strong> Operations used to send changes to or retrieve updates from a remote repository (such as GitHub).</li><li><strong>Merge:</strong> The process of combining changes from different branches into a single branch.</li></ul><h4>Git Command Line and GitHub</h4><p>Although graphical tools like GitHub Desktop are available, the <strong>command line interface (CLI)</strong> provides the most complete access to Git’s capabilities. Mastering the Git CLI allows developers to work more efficiently and with greater control.</p><p><strong>GitHub</strong>, 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.</p><h3>Module 2: Introduction to GitHub</h3><p>GitHub is a cloud-based platform built on top of <strong>Git</strong>, 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.</p><p>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.</p><h4>The Foundation of GitHub: Git</h4><p>Before fully understanding GitHub, it is essential to understand <strong>Git</strong> 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.</p><h4>Core Features of GitHub</h4><h4>Collaboration</h4><p>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.</p><p>In addition, GitHub offers AI-powered tools such as <strong>GitHub Copilot</strong>, which assists developers while writing code and helps improve productivity throughout the development lifecycle.</p><h4>Productivity and Automation</h4><p>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.</p><h4>Security</h4><p>Security is embedded into GitHub’s development workflow. Tools such as <strong>CodeQL</strong>, <strong>Dependabot</strong>, and <strong>secret scanning</strong> help identify vulnerabilities early in the development process. These built-in security features are trusted by organizations of all sizes, including Microsoft.</p><h4>Scale and Community</h4><p>With over <strong>100 million developers</strong> and <strong>hundreds of millions of repositories</strong>, GitHub hosts one of the largest developer communities in the world. This scale drives innovation, knowledge sharing, and continuous improvement across the platform.</p><h4>AI Integration</h4><p>GitHub leverages generative AI to enhance the developer experience. Tools like <strong>GitHub Copilot</strong>, AI-assisted pull requests, and intelligent issue management help streamline collaboration and improve code quality.</p><h4>GitHub Repositories: The Center of Your Project</h4><p>A <strong>repository</strong> (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.</p><p>Key repository actions include:</p><ul><li><strong>Creating a repository:</strong> Set up a project with a name, description, and visibility (public or private).</li><li><strong>Cloning a repository:</strong> Create a local copy of a repository to work offline and sync changes later.</li><li><strong>Adding and committing files:</strong> Upload or modify files and commit changes to track progress over time.</li></ul><h4>Additional GitHub Features</h4><p>GitHub provides several supporting tools that enhance development workflows:</p><ul><li><strong>Gists:</strong> Lightweight repositories ideal for sharing small code snippets or notes.</li><li><strong>Wikis:</strong> Built-in documentation spaces for guides, design documents, and references.</li><li><strong>GitHub Pages:</strong> A feature that allows hosting static websites directly from a repository.</li></ul><h4>GitHub Enterprise: Tools for Teams and Organizations</h4><p>For larger teams and organizations, <strong>GitHub Enterprise</strong> offers enhanced capabilities, including:</p><ul><li>AI-powered productivity tools such as Copilot and Copilot Chat</li><li>Advanced collaboration features that improve workflow efficiency</li><li>Enterprise-level security with automated vulnerability scanning and dependency management</li></ul><h4>Understanding GitHub Flow</h4><p><strong>GitHub Flow</strong> 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.</p><h4>Branches: Isolated Development</h4><p>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.</p><h4>Commits: Recording Progress</h4><p>A <strong>commit</strong> 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.</p><p>Files move through clear stages — from untracked to committed — ensuring changes are intentional and traceable.</p><h4>Pull Requests: Reviewing and Merging Changes</h4><p>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.</p><h4>The GitHub Flow in Practice</h4><p>A typical GitHub Flow follows these steps:</p><ol><li>Create a new branch.</li><li>Make incremental commits.</li><li>Open a pull request.</li><li>Review and discuss changes.</li><li>Merge the pull request.</li><li>Delete the branch once complete.</li></ol><p>This lightweight workflow is ideal for continuous delivery and fast-moving teams.</p><h4>Git Flow: A Structured Alternative</h4><p><strong>Git Flow</strong> is a more formal branching model designed for release-based development. It introduces dedicated branches for development, features, releases, and hotfixes.</p><p>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.</p><h3>Module 3: Introduction to GitHub Products</h3><p>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.</p><h4>GitHub Account Types</h4><p>GitHub provides three primary account types: <strong>Personal</strong>, <strong>Organization</strong>, and <strong>Enterprise</strong>. Each serves a distinct purpose and offers different levels of control and governance.</p><h4>Personal Accounts</h4><p>A personal account represents an individual developer’s identity on GitHub. Every user who signs up receives a unique username and profile.</p><p>With a personal account, you can:</p><ul><li>Create and own repositories, packages, and projects</li><li>Collaborate on public and private repositories</li><li>Contribute to other projects through pull requests and issues</li></ul><p>All activity — such as commits, reviews, and comments — is attributed to your personal account.</p><p>Available plans:</p><ul><li>GitHub Free</li><li>GitHub Pro</li></ul><h4>Organization Accounts</h4><p>Organization accounts provide shared workspaces for teams. Members access the organization using their personal accounts, while permissions are managed through roles and teams.</p><p>Key capabilities include:</p><ul><li>Unlimited members and collaborators</li><li>Team-based permission and access control</li><li>Shared ownership of repositories and packages</li></ul><p>Organization owners and security managers can enforce policies, manage settings, and protect sensitive data at scale.</p><h4>Enterprise Accounts</h4><p>Enterprise accounts are designed for large organizations managing multiple organizations under a centralized structure.</p><p>Enterprise administrators can:</p><ul><li>Enforce security and compliance policies across all organizations</li><li>Manage authentication and billing centrally</li><li>Enable inner sourcing by sharing code internally between teams</li></ul><p>Enterprise accounts support integration with external identity providers to ensure secure and consistent access management.</p><h4>GitHub Plans and Pricing</h4><p>Once an account type is selected, the next step is choosing a plan that aligns with your workflow and team size.</p><h4>GitHub Free</h4><p>GitHub Free is ideal for individuals and small teams getting started.</p><p>For personal accounts:</p><ul><li>Unlimited public and private repositories</li><li>Unlimited collaborators</li><li>Limited GitHub Actions minutes and Codespaces usage</li><li>Basic community support</li></ul><p>For organizations:</p><ul><li>Unlimited repositories and collaborators</li><li>Team-based access controls</li></ul><p>This plan is well suited for learning, open-source contributions, and small-scale collaboration.</p><h4>GitHub Pro</h4><p>GitHub Pro is designed for individual developers who require more advanced tooling.</p><p>In addition to Free features, it includes:</p><ul><li>Email support</li><li>Increased GitHub Actions and Packages limits</li><li>Protected branches and required reviewers</li><li>Repository insights, Wikis, and GitHub Pages</li></ul><p>This plan works well for freelancers and developers managing multiple private projects.</p><h4>GitHub Team</h4><p>GitHub Team supports organizations that need stronger collaboration and governance capabilities.</p><p>Key additions include:</p><ul><li>Team-based access controls</li><li>Draft and team pull requests</li><li>Scheduled reminders</li><li>Advanced repository insights</li></ul><p>It is a strong choice for small to mid-sized teams seeking efficient workflows and better coordination.</p><h4>GitHub Enterprise</h4><p>GitHub Enterprise is the most comprehensive plan, built for large-scale operations with advanced security and compliance requirements.</p><p>Enterprise features include:</p><ul><li>Centralized policy enforcement</li><li>Enterprise-grade identity and access management</li><li>Advanced security and auditing tools</li><li>Dedicated enterprise support</li></ul><h4>Enterprise Deployment Options</h4><ul><li><strong>GitHub Enterprise Cloud:</strong> Fully managed by GitHub with high availability and centralized billing</li><li><strong>GitHub Enterprise Server:</strong> Self-hosted solution for organizations with strict infrastructure or data requirements</li></ul><h4>Enterprise Managed Users (EMU)</h4><p>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.</p><h4>GitHub Copilot Availability</h4><p>GitHub Copilot is not included by default in standard plans. However, <strong>Copilot Business</strong> and <strong>Copilot Enterprise</strong> can be added as separate subscriptions to enhance developer productivity with AI-assisted coding.</p><h4>Understanding GitHub Billing and Payments</h4><p>GitHub’s billing system is designed to scale with usage and organizational needs while maintaining transparency and control.</p><h4>How Billing Works</h4><p>Billing is organized by account type:</p><ul><li>Personal</li><li>Organization</li><li>Enterprise</li></ul><p>Each account typically has its own bill, though enterprises can consolidate billing across multiple organizations.</p><p>Billing consists of:</p><ol><li><strong>Subscription charges</strong> for plans and add-ons</li><li><strong>Usage-based charges</strong> for services such as GitHub Actions, Packages, and Codespaces</li></ol><p>Most plans include a baseline amount of free usage, with spending limits available to control overages.</p><h4>GitHub Actions Pricing</h4><p>GitHub Actions pricing depends on repository visibility:</p><ul><li><strong>Public repositories:</strong> Unlimited free minutes</li><li><strong>Private repositories:</strong> Metered usage based on plan limits</li></ul><p>Monitoring usage is essential to avoid unexpected charges, particularly in automation-heavy projects.</p><h4>Usage-Based License Billing</h4><p>GitHub supports usage-based billing for licenses, allowing organizations to pay only for what they use.</p><p>Key characteristics:</p><ul><li>Monthly billing based on active license usage</li><li>Pro-rata charges for mid-month changes</li><li>Automatic adjustments when license usage changes</li></ul><p>This model provides flexibility and cost efficiency without requiring upfront bulk purchases.</p><h4>GitHub’s Enhanced Billing Platform</h4><p>GitHub’s billing platform offers advanced financial management tools, including:</p><ul><li>Spending limits for usage-based services</li><li>Detailed consumption insights</li><li>Automated reports for cost tracking and allocation</li></ul><p>Additional considerations:</p><ul><li><strong>Codespaces</strong> are billed separately based on compute and storage usage</li><li><strong>Billing alerts</strong> notify administrators when spending approaches defined limits</li></ul><p>These features help organizations maintain budget control while gaining clear visibility into resource usage.</p><h3>Module 4: Configure Code Scanning on GitHub</h3><p><strong>Code scanning</strong> 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.</p><p>Scan results appear as alerts in the <strong>Security</strong> tab of a GitHub repository. These alerts are automatically closed once the underlying issue is fixed.</p><p>At the core of GitHub’s code scanning is <strong>CodeQL</strong>, GitHub’s powerful code analysis engine. CodeQL treats code as data, allowing sophisticated queries to detect security flaws and quality issues with high accuracy.</p><h4>Key Features of Code Scanning</h4><p>Code scanning provides several important capabilities:</p><ul><li>Detects security vulnerabilities and common coding errors</li><li>Supports multiple programming languages, including:</li><li>C / C++</li><li>C#</li><li>Go</li><li>Java / Kotlin</li><li>JavaScript / TypeScript</li><li>Python</li><li>Ruby</li><li>Swift</li></ul><p>Available for:</p><ul><li><strong>Public repositories</strong> (free)</li><li><strong>Private repositories</strong> with <strong>GitHub Advanced Security</strong></li></ul><h4>How Code Scanning Works</h4><p>Code scanning follows a structured process:</p><ol><li><strong>CodeQL Database Creation</strong><br> A database is generated that represents the structure and behavior of the code.</li><li><strong>Running CodeQL Queries</strong><br> Predefined or custom queries are executed against the database to identify potential issues.</li><li><strong>Alerts and Feedback</strong><br> Results are displayed as code scanning alerts in GitHub. When the vulnerable code is fixed, related alerts are automatically resolved.</li></ol><p>This workflow enables continuous security monitoring with minimal manual effort.</p><h4>Code Scanning Setup Options</h4><p>GitHub provides multiple ways to configure code scanning depending on your needs.</p><h4>Default Setup</h4><p>The default setup is the fastest way to get started:</p><ul><li>Automatically configured using GitHub Actions</li><li>GitHub selects supported languages and query suites</li><li>Runs automatically on:</li></ul><p><em>push</em></p><p><em>pull_request </em>events</p><p>This option is ideal for most repositories and requires little to no manual configuration.</p><h4>Advanced Setup</h4><p>Advanced setup allows full customization:</p><p>1- Adds a CodeQL workflow file to the repository</p><p>2- Enables manual control over:</p><ul><li>Queries</li><li>Triggers</li><li>Workflow steps</li></ul><p>This option is recommended for teams with specific security policies or custom analysis requirements.</p><p>External CI Setup</p><p>Code scanning can also be executed outside GitHub:</p><ul><li>Run <strong>CodeQL CLI</strong> on an external system</li><li>Upload analysis results back to GitHub</li><li>Suitable for complex CI environments or restricted infrastructures</li></ul><h4>When Code Scanning Runs (Triggers)</h4><p>Code scanning can be triggered automatically when:</p><ul><li>Code is pushed to a protected branch</li><li>A pull request is opened against the default branch</li></ul><p>This ensures new changes are analyzed before being merged into critical branches.</p><h4>Billing Considerations</h4><p>Code scanning runs on <strong>GitHub Actions</strong>, so usage affects your Actions quota:</p><ul><li><strong>Public repositories:</strong> Free</li><li><strong>Private repositories:</strong> Consumes Action minutes based on your plan<br> (Free, Pro, Team, or Enterprise)</li></ul><p>Additional usage beyond the included quota may incur extra charges.</p><h4>External Analysis and SARIF Integration</h4><p>Instead of running code scanning directly on GitHub, you can analyze code externally using tools such as <strong>ESLint</strong>, <strong>SonarQube</strong>, or custom static analysis tools.</p><p>The results must be uploaded to GitHub in <strong>SARIF</strong> format.</p><ul><li>Required format: <strong>SARIF (Static Analysis Results Interchange Format) v2.1.0</strong></li><li>Uploaded results appear in the <strong>Security</strong> tab, just like native GitHub scans</li></ul><h4>Ways to Upload SARIF Files</h4><p>There are three primary methods to upload SARIF results.</p><h4>Upload via GitHub REST API</h4><p>You can manage code scanning alerts programmatically:</p><ul><li>Use code scanning API endpoints</li><li>Example endpoint:</li></ul><pre>/orgs/ORG/code-scanning/alerts</pre><ul><li>Requires the application/sarif+json media type</li><li>Useful for automated or offline analysis pipelines</li></ul><h4>Upload via CodeQL CLI</h4><p>The CodeQL CLI allows you to:</p><ul><li>Generate a CodeQL database</li><li>Run queries locally</li><li>Export results as a SARIF file</li><li>Upload results to GitHub</li></ul><blockquote><strong><em>Note: Private repositories require a GitHub Advanced Security license.</em></strong></blockquote><h4>Upload via GitHub Actions</h4><p>GitHub Actions can automate SARIF uploads as part of your CI pipeline.</p><h4>Example GitHub Actions Workflow</h4><pre>name: &quot;Upload SARIF&quot;<br>on:<br>  push:<br>  schedule:<br>    - cron: &#39;45 15 * * 4&#39; # Runs weekly<br><br>jobs:<br>  build:<br>    runs-on: ubuntu-latest<br>    permissions:<br>      security-events: write<br>    steps:<br>      - name: Checkout repository<br>        uses: actions/checkout@v2<br><br>      - name: Upload SARIF file<br>        uses: github/codeql-action/upload-sarif@v1<br>        with:<br>          sarif_file: results.sarif</pre><h4>Important Notes</h4><ul><li>Supports single SARIF files or directories</li><li>Can run on push or on a scheduled basis</li><li>Supports partialFingerprints to avoid duplicate alerts</li></ul><p>Maximum:</p><ul><li>5,000 results per upload</li><li>10 MB compressed SARIF file size</li></ul><h4>CI Integration with External Tools</h4><p>If your CI pipeline generates SARIF output, you can upload it directly to GitHub.</p><h4>Example with ESLint</h4><pre>- name: Run ESLint<br>  run: eslint . -f sarif -o results.sarif<br><br>- name: Upload SARIF file<br>  uses: github/codeql-action/upload-sarif@v1<br>  with:<br>    sarif_file: results.sarif</pre><p>Once uploaded, GitHub processes the SARIF file and displays alerts in the repository’s <strong>Security</strong> tab.</p><h4>Summary</h4><ul><li>Code scanning detects vulnerabilities and quality issues automatically</li><li>Powered by CodeQL</li><li>Supports native scans and external tools</li><li>SARIF enables flexible security integration</li><li>Alerts are centralized in GitHub for visibility and collaboration</li></ul><h3>Module 5: GitHub Copilot</h3><p>GitHub Copilot is an <strong>AI pair programmer</strong> developed by GitHub and OpenAI (powered by OpenAI Codex). It helps developers:</p><ul><li>Autocomplete code and comments.</li><li>Generate unit tests.</li><li>Suggest bug fixes.</li><li>Assist across the entire development lifecycle.</li></ul><p>It integrates with <strong>VS Code, Visual Studio, Vim/Neovim, and JetBrains IDEs.</strong></p><h4>Key Benefits</h4><ul><li>46% of new code is AI-generated for Copilot users.</li><li>55% faster productivity on real-world projects.</li><li>74% of developers report feeling more focused on satisfying work.</li></ul><h4>Copilot Features</h4><ol><li><strong>Copilot for Chat</strong></li></ol><ul><li>ChatGPT-like interface inside the IDE.</li><li>Can explain code, generate tests, and suggest bug fixes.</li></ul><p>2. <strong>Copilot for Pull Requests</strong></p><ul><li>AI-generated PR tags and descriptions.</li><li>Helps summarize code changes automatically.</li></ul><p>3.<strong> Copilot for CLI</strong></p><ul><li>Compose commands and loops for the terminal.</li><li>Reduces need to remember exact command syntax.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*D79RIMlXvF-UeqVUa1NhCQ.png" /></figure><p><strong>1. Inline Suggestions</strong></p><ul><li>Provides real-time code completions as you type.</li><li>Accept with Tab or right arrow, reject with Esc.</li><li>Useful for repetitive or boilerplate code.</li></ul><p><strong>2. Command Palette</strong></p><ul><li>Quick access to Copilot functions.</li><li>Allows generating explanations, unit tests, and other actions via shortcuts.</li></ul><p><strong>3. Copilot Chat</strong></p><ul><li>Interactive chat within the IDE using natural language.</li><li>Ask questions or request code snippets.</li></ul><p><strong>4. Inline Chat</strong></p><ul><li>Context-specific conversations directly in the code editor.</li><li>Request modifications or explanations for a specific code section.</li></ul><p><strong>5. Slash Commands</strong></p><p>Quick commands to interact with Copilot:</p><ul><li>/explain — Explains code</li><li>/suggest — Offers code suggestions</li><li>/tests — Generates unit tests</li><li>/comment — Converts comments into code</li></ul><p><strong>6. Comments to Code</strong></p><ul><li>Describe functionality in a comment, Copilot generates the corresponding code.</li></ul><p><strong>7. Multiple Suggestions</strong></p><ul><li>Cycle through alternative code suggestions to choose the best approach.</li></ul><p><strong>8. Explanations</strong></p><ul><li>Get explanations for selected code blocks to understand or review them.</li></ul><p><strong>9. Automated Test Generation</strong></p><ul><li>Automatically generates unit tests for functions or classes.</li></ul><h3><strong>Module 6:</strong> Code with GitHub Codespaces</h3><p>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.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*xV9xMH3NBkXU-yA0lroQLw.png" /></figure><p>You can create a Codespace on GitHub.com, in Visual Studio Code, or by GitHub CLI. There are four ways to create a Codespace:</p><ul><li>From a GitHub template or any template repository on GitHub.com to start a new project.</li><li>From a branch in your repository, for new feature work.</li><li>From an open pull request, to explore work-in-progress.</li><li>From a commit in a repository’s history to investigate a bug at a specific point in time.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*Y9zJXSbiP1FB5hALfY_bvw.png" /></figure><p>When you create a GitHub Codespace, four processes occur:</p><ol><li>A virtual machine and storage are assigned to your Codespace.</li><li>A container is created.</li><li>A connection to the Codespace is made.</li><li>A post-creation setup is made.</li></ol><p>When you rebuild the container in a Codespace, changes you made outside the<em> /workspaces</em> directory are cleared. Changes you made inside the <em>/workspaces </em>directory, including the clone of the repository or template you created the Codespace from, are preserved over a rebuild.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*3R9Mj3rLVT69_G4SArFkeA.png" /></figure><h3><strong>Module 7:</strong> Manage Your Work with GitHub Projects</h3><p>GitHub has reimagined how we plan, track, and manage work. The new <strong>GitHub Projects</strong> goes far beyond “Projects (Classic),” offering a more flexible, data-driven, and customizable experience for teams and individuals.</p><h4><strong>Tables &amp; Boards</strong></h4><p>In the new Projects, you can work with <strong>tables or boards</strong> — whichever fits your workflow. <br> You can <strong>rank, sort, and group</strong> items by any custom field, create <strong>draft issues</strong> with full descriptions, and use <strong>token-based filters</strong> to customize your view. <br> Real-time updates and user presence indicators make collaboration seamless.</p><h4><strong>Data &amp; Custom Fields</strong></h4><p>Unlike the limited columns of Classic Projects, the new Projects lets you define <strong>custom fields</strong> — text, number, date, iteration, or single select. <br> You can even configure <strong>iterations</strong> for agile sprints or quarterly planning and see <strong>linked pull requests and reviewers</strong> directly in your view.</p><h4><strong>Insights &amp; Reporting</strong></h4><p>Projects now includes <strong>built-in charts</strong> (bar, line, column, stacked area) that you can fully customize. <br> Use functions like <strong>sum, count, average, min, or max</strong> to gain instant visibility into progress, and share charts easily via unique URLs.</p><h4><strong>Automation</strong></h4><p>Automation is now smarter and more powerful:</p><ul><li><strong>GraphQL ProjectsV2 API</strong> for advanced integration</li><li><strong>Webhooks</strong> for real-time updates</li><li><strong>GitHub Actions</strong> to automate adding or updating project items</li></ul><h4><strong>Mastering Project Management: Visibility, Automation, and Insights</strong></h4><p>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.</p><p>Here is a recap of how to effectively manage the structure, access, and lifecycle of your project based on the provided training material.</p><h4><strong>1. Organizing Your Work for Focus</strong></h4><p>Effective organization starts with structured fields and customized views.</p><h4><strong><em>Utilizing Priority and Iteration Fields</em></strong></h4><p>To keep track of ongoing work, you can create custom fields in the table view:</p><ul><li><strong>Priority Fields:</strong> Use the <strong>Single select</strong> field type to create classifications like <strong>Urgent</strong>, <strong>High</strong>, <strong>Medium</strong>, and <strong>Low</strong>. Once classified, you can <strong>Group by</strong> <em>Priority</em> 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.</li><li><strong>Iteration Fields:</strong> Adding an <em>Iteration</em> field (e.g., named <em>Project Phase</em> or <em>Sprint</em>) helps visualize the balance of upcoming work in tangible timeframes. When setting up an Iteration field, you define the <strong>Starts On</strong> date and the <strong>Duration</strong> (in days or weeks).</li></ul><h4><strong><em>Creating Visual Board Views</em></strong></h4><p>While the table view is useful for data entry, a <strong>Board</strong> 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 <strong>Board</strong> under <em>Layout</em>. In the board view, you can drag and drop issues and pull requests between columns. Remember to save your modified views.</p><h4><strong><em>Converting Checklist Items</em></strong></h4><p>For better task tracking and hierarchy, GitHub Projects supports <strong>converting checklist items into sub-issues</strong>. This creates a dedicated, linked issue that appears in your Project view.</p><h4><strong>2. Controlling Visibility and Managing Access</strong></h4><p>A core aspect of project management is defining who can see and interact with your project.</p><h4><strong><em>Setting Project Visibility</em></strong></h4><p>You can control whether your project is <strong>public</strong> (viewable by everyone on the internet) or <strong>private</strong> (viewable only by users granted at least read access).</p><p>To change visibility, navigate to your Project, select the three dots menu, choose <strong>Settings</strong>, scroll to the <strong>Danger zone</strong>, and select Private or Public under <strong>Visibility</strong>.</p><h4><strong><em>Understanding Access Levels</em></strong></h4><p>Project access management differs depending on whether the Project is <strong>organization-owned</strong> or <strong>personal/user-owned</strong>:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1012/1*wjPr6q57ftDtVBmD1xbbYw.png" /></figure><p>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.</p><p>You can invite collaborators or change their roles by navigating to <strong>Settings</strong> and selecting <strong>Manage access</strong> from the left-hand navigation bar.</p><h4><strong><em>Linking Projects to Teams and Repositories</em></strong></h4><ul><li><strong>Add to a Team:</strong> Adding a Project to a team grants the team <strong>read permissions</strong> and lists the Project on the team’s Projects page, making it easier for members to identify the Projects their team uses.</li><li><strong>Add to a Repository:</strong> 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.</li></ul><h4><strong>3. Leveraging Insights and Automation</strong></h4><p>Projects offer methods to visualize progress and automate routine tasks.</p><h4><strong><em>Gaining Insights with Charts</em></strong></h4><p>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.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*aPhtrQozqmrRBiLOjDBULA.png" /></figure><p><strong>Current Charts:</strong> 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.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/936/1*C7efoQkW8tDd4TdIi0p1Eg.png" /></figure><p><strong>Historical Charts:</strong> Available with GitHub Team and GitHub Enterprise Cloud for organizations, these are <strong>time-based charts</strong> that show trends and progress. The default <em>Burn up</em> chart visualizes item status over time, helping to spot patterns.</p><p>To create a new chart, navigate to your Project, select the <strong>Insights</strong> line graph button in the top-right, and choose <strong>New chart</strong>. You can customize the chart by selecting <strong>Configure</strong> on the right side to change the <strong>Layout</strong> and the fields used for the <strong>X-axis</strong> and <strong>Group by</strong> function.</p><h4><strong><em>Automating Tasks</em></strong></h4><p>You can automate your Project using three methods: built-in automated workflows (easiest), GraphQL API, or GitHub Actions with workflows.</p><p><strong>Built-in Workflows:</strong> 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 <em>Todo</em> status.</p><p>To enable a default workflow:</p><ol><li>Select the three dots menu and choose <strong>Workflows</strong>.</li><li>Select a trigger, such as <strong>Item added to project</strong>.</li><li>Configure the status (e.g., select <strong>Status:Todo</strong> in the <strong>Set Value</strong> section).</li><li>Select <strong>Save and turn on workflow</strong>.</li></ol><p><strong>GitHub Actions:</strong> 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.</p><h4><strong>4. Closing and Deleting Projects</strong></h4><p>Once a Project is complete or no longer needed, you can manage its lifecycle. Both closing and deleting options are found in the <strong>Danger zone</strong> section of the Project <strong>Settings</strong>.</p><ul><li><strong>Closing a Project:</strong> 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.</li><li><strong>Deleting a Project:</strong> This action <strong>permanently removes</strong> the Project from the platform, along with associated saved views, custom fields, insights data, and drafted issues. Selecting <strong>Delete project</strong> prompts you to read warnings and requires typing the name of the Project for confirmation.</li></ul><h3><strong>Module 8:</strong> Communicate Effectively on GitHub Using Markdown</h3><p>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.</p><p>In this module from <strong>Microsoft Learn</strong>, Markdown is introduced along with its structure, syntax, and the additional features provided by <strong>GitHub-Flavored Markdown (GFM)</strong> — a set of extensions that make collaboration on GitHub easier and more efficient.</p><h4>Basic Markdown Syntax</h4><p>Markdown provides intuitive syntax for formatting text and organizing content.</p><h4>Emphasis</h4><p>Text can be styled for emphasis in multiple ways:</p><ul><li><em>Italic</em> text is created using single asterisks (*) or underscores (_)</li><li><strong>Bold</strong> text uses double asterisks (**) or double underscores (__)</li><li>Mixed emphasis is also possible, such as:<br> _This is **italic and bold** text_</li></ul><p>To display literal asterisks or underscores instead of triggering formatting, you can escape them using a backslash (\) in GitHub-Flavored Markdown.</p><h4>Headings</h4><p>Headings use the hash symbol (#) to define hierarchy.<br> Markdown supports six heading levels:</p><pre># Heading 1<br>## Heading 2<br>###### Heading 6</pre><p>Each additional hash represents a lower-level heading.</p><h4>Lists and Tables</h4><p>Markdown supports both ordered and unordered lists:</p><ul><li>Ordered lists use numbers</li><li>Unordered lists use asterisks (*) or hyphens (-)</li><li>Nested list items are created using indentation</li></ul><p>Tables are created using pipes (|) to separate columns and dashes (-) to define header rows.</p><h4>Links and Quotes</h4><ul><li>Links and images follow a similar syntax structure</li><li>Blockquotes are created using the greater-than symbol (&gt;)</li></ul><p>These features make it easy to reference documentation, external resources, or important notes.</p><h4>Code Blocks</h4><p>Markdown allows both inline and multi-line code formatting:</p><ul><li>Inline code is wrapped in backticks (`)</li><li>Multi-line code uses fenced code blocks with three backticks (```)</li></ul><p>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 (&lt;br&gt;).</p><h4>GitHub-Flavored Markdown (GFM) Enhancements</h4><p>GitHub extends standard Markdown to better support collaboration, code review, and project tracking.</p><h4>Syntax Highlighting</h4><p>GFM enables syntax highlighting by specifying the language after the opening triple backticks:</p><pre>console.log(&quot;Hello, GitHub!&quot;);</pre><p>This makes code easier to read and understand.</p><h4>Cross-linking</h4><p>GitHub allows easy linking to issues, pull requests, and commits:</p><ul><li>Use #ID to reference issues or pull requests (e.g., #3602)</li><li>Paste a commit hash (SHA) to link directly to a commit</li></ul><h4>Mentions and Task Tracking</h4><ul><li>Typing @username mentions a user or team and sends a notification</li><li>Task lists help track progress inside issues and pull requests:</li></ul><pre>- [x] First task<br>- [ ] Second task</pre><h4>Slash Commands</h4><p>Slash commands help you create structured content faster in comment and description fields. Common commands include:</p><ul><li>/code – Inserts a Markdown code block</li><li>/table – Inserts a Markdown table</li><li>/tasklist – Inserts a task list in an issue or pull request</li></ul><p>These shortcuts reduce friction and help maintain consistency across GitHub content.</p><p>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.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9a9798cdb9e0" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>