Cheatsheets

README

Wed, 11 Feb 2026 18:19:30 GMT

Live site: https://krillinator.github.io/developer-fundamentalsPractical notes and tutorials covering the core fundamentals every developer needs. Built for beginners. Focused on real workflows.Built in Obsidian and version-controlled with Git. Terminal / Command Line Navigation, files, productivity (Mac, Linux, Windows) Git & GitHub Commits, branches, workflows, pull requests Programming Fundamentals (expanding over time) Step-by-step tutorials Visual diagrams Cheatsheets & callouts Practical examples

Summarized by chat-GPT - thanks!

Agile - Planning Poker

Wed, 11 Feb 2026 18:20:13 GMT

Planning Poker is a simple way for a team to estimate how much effort a user story requires. It helps the team agree on complexity before committing to work. Think of it as: “A quick team vote to understand effort before building.” Product Owner presents a story Team asks clarifying questions Everyone privately selects a number (story points) All reveal at the same time If numbers differ → discuss → vote again Repeat until the team agrees.

Product Owner begins by navigating to: https://planningpokeronline.com/new-game/ Pick 'modified fibonacci' --> Create game --> Share Link

At the top right section you may create new User Stories (called issues here) and assign points, revote and get an overview
This ensures better control when voting, deciding or revisiting certain User Stories
Pick an already defined User Story, present it and proceed to vote. After everyone has voted, discuss the results. Then vote again (if there's no consensus) (If you're unsure about the cards meaning: check out the table section bellow ) How many voting rounds? There is no fixed number. Typically: • First vote --> Wide spread of numbers • Discussion • Second vote --> Closer alignment • (Sometimes) Third vote --> Final agreement If the team cannot align after 2–3 rounds, the story is likely unclear or too large and should be refined or split.The Card Set: Table Story points represent relative effort, complexity, and uncertainty.. not time. What happens after everyone picks? Everyone reveals their card at the same time. If the numbers differ, discussion begins. The highest and lowest estimates explain their reasoning. The team discusses assumptions, risks, and unknowns. The team votes again. The goal is not to “win” the estimate. The goal is shared understanding. If estimates are very high (40 / 100), the story is usually too big and should be split. Prevents one person from deciding alone Encourages discussion Reveals misunderstandings early Creates shared ownership Planning Poker is about understanding the work, not predicting exact hours. The Product Owner can now decide much easier how to distribute workload over the coming sprints and whether or not it's worth the time and effort.

Back to Agile - Workflow

Screenshot 2026-02-11 at 16.23.27

Wed, 11 Feb 2026 15:23:30 GMT

Screenshot 2026-02-11 at 16.23.05

Wed, 11 Feb 2026 15:23:09 GMT

Screenshot 2026-02-11 at 16.20.39

Wed, 11 Feb 2026 15:20:43 GMT

Screenshot 2026-02-11 at 16.09.26

Wed, 11 Feb 2026 15:09:31 GMT

Agile - Workflow

Wed, 11 Feb 2026 18:20:13 GMT

Before You Begin Gather the team Assign roles (Product Owner, Scrum Master, Development Team) Agile - Roles
Brainstorm ideas Agile - Brainstorming
Define the MVP Agile - MVP
Create user stories User Stories vs Technical User Stories
Prioritize the backlog Agile - Backlog Prioritization
Estimate stories Agile - Planning Poker Select stories for Sprint 1 Goal: Decide what to build this sprint.Do this: Product Owner presents prioritized stories Team clarifies the story to fully understand what needs to be built (understanding mission) Team estimates effort (Planning Poker if needed) Team selects stories they can finish Stories are assigned to this sprint Now the sprint starts.
Every day: Short daily standup (What did I do? What will I do? Any blockers?) Developers move stories: Todo → In Progress → Done Scrum Master removes obstacles No new work added to the sprint Focus: Finish what you committed to.
Goal: Show what was completed. Team demonstrates finished work Stakeholders (clients, customers, managers etc..) give feedback Only “Done” work is shown
Goal: Improve teamwork.Discuss: What worked well? What didn’t? What should we improve next sprint? Pick 1–2 improvements.
Repeat the cycle.

Pasted image 20260211155053

Wed, 11 Feb 2026 14:50:53 GMT

Pasted image 20260211155012

Wed, 11 Feb 2026 14:50:12 GMT

Agile - Roles

Wed, 11 Feb 2026 18:20:13 GMT

Agile roles define how a team collaborates to plan, build, and deliver software in short iterations. Each role has a clear responsibility to keep focus, quality, and progress aligned. Think of it as: “Clear responsibilities that prevent chaos and keep the team moving forward.” Product Owner "Owns the backlog and prioritizes user stories"
Product Owner Decides what should be built and in what order. Owns and prioritizes the backlog Writes / refines user stories Decides what should be built Moves stories in priority order Scrum Master "Facilitates the process"
Scrum Master Removes obstacles and protects the team’s focus. Runs the meetings (Sprint Planning, Daily Standup, Review, Retrospective) Helps solve problems that slow the team down Makes sure no new work is added during the sprint Helps the team understand and follow Scrum rules Makes sure everyone is included Development Team "Designs, builds, tests, and delivers the product"
Development Team Decides how the work gets done. Moves stories during the sprint (Todo → In Progress → Done) Updates status daily (keep story status up to date) Splits a story into smaller, concrete steps needed to finish it (During Sprint Planning) Example: “As a user, I want to reset my password.” Create reset endpoint Add email validation Create reset token logic Update UI form Write tests Before we start building, we need clear roles so we don’t step on each other’s toes. Let’s quickly decide who takes which responsibility Who wants to own the product direction and backlog? (Product Owner) Who feels comfortable facilitating meetings and keeping us on track making sure everyone feels included during the Agile Meetings? (Scrum Master) The rest are the development team. Important: The Product Owner decides what to build The Scrum Master ensures how the team works Neither role has to be a manager
Clear roles: Reduce confusion Improve accountability Speed up decision-making Support healthy sprint cycles Without clear roles, planning becomes opinion-driven. With roles, the team works as a structured unit.
Both roles are assigned before the team starts working in sprints.Usually: When a new project begins When a team is formed Before the first Sprint Planning You don’t change roles mid-sprint unless absolutely necessary.
Simple rule: Set roles before Sprint 1. Keep roles stable during the sprint.
Brainstorming Agile - Brainstorming

Agile - Brainstorming

Wed, 11 Feb 2026 18:20:13 GMT

Goal: Generate many ideas fast — no filtering yet. Think of it as: “Collect first, judge later.”
Criticism (“that’s stupid”, “won’t work”) Debates / long discussions Estimations (“too big”, “too hard”) Solutions too early (“the best architecture is…”) “Yes, but…” energy These do NOT belong in Brainstorming phaseScrum Master Scrum master holds the line of defense and helps the team move forward when things get complicated, team start discussing tech through debates, keeps time and makes sure everyone participates. Quantity > quality Be specific, keep it short Build on ideas: “Yes, and…” Questions are allowed (put them in Questions)

Everyone opens Excalidraw: https://excalidraw.com/ Product Owner creates a shared board Click Share (top right)
Copy the link and share it with the team
Before taking next step, ask yourselves: What are we building? Who is it for? What problem are we solving? Use a timer on 4-6 minutes Write down ALL your ideas
Once done, everyone puts down 3 dots on their favourites. Discuss and then move on to the next step Create 3 zones on the canvas Ideas Questions Constraints (tech, knowledge, time) Set a timer (5–10 min) Everyone adds notes silently One idea per note
Short phrases (3–7 words) Dot-vote (optional, 2 min) Everyone adds up to 3 dots ⭐ on their favorite notes (per category) Capture outcomes / discuss Screenshot/export the board Move to MVP/prioritization after brainstorming Reminder Save the data somewhere, as the ideas and feedback will be used in the next step
Minimal Viable Product Agile - MVP

Agile - MVP

Wed, 11 Feb 2026 18:20:14 GMT

MVP (Minimum Viable Product) is the smallest version of a product that still delivers real value. Think of it as: “The simplest version that works and can be tested.” When the Product Owner prioritizes stories, they ask: "What do we need to build first to have a usable product?" What should our first presentation be done in? UI, Postman, Swagger..? What about: database tech, and libraries? Not: What would be nice? What would be cool? What would impress people? Only: What is essential?
Let’s say you're building a task app.Possible features: Create task Delete task Edit task User login Dark mode Task reminders Analytics dashboard MVP might be: Create task Delete task View task list Everything else comes later.An example from the previous brainstorm might be to then mark the relevant MVP related work

What would you want to show the client? Build what is necessary to make it usable. What is the smallest possible usable version? Improve it after feedback. That’s why MVP and backlog prioritization go hand in hand.
Backlog Prioritization Agile - Backlog Prioritization

Screenshot 2026-02-11 at 13.22.30

Wed, 11 Feb 2026 12:22:33 GMT

Agile - Backlog Prioritization

Wed, 11 Feb 2026 18:20:14 GMT

Priority decides what should be built first. After defining the MVP, we still need to decide the order of work. Not everything can be built at once. Think of it as: “Choosing what we build first, second, and third.” Ask yourself this: Why are we building dark mode if users still can’t create an account? Priority helps the team: Build the most important things first Avoid working randomly Handle dependencies correctly Deliver value early
Ask three questions: Is this required for the product to work? Does something else depend on this? Does this create high user value? If the answer is “yes” → it goes higher in the backlog.
MVP defines what is essential. Priority defines what comes first in the sprint.
Back to Agile - Workflow

Pasted image 20260211130028

Wed, 11 Feb 2026 12:00:28 GMT

Pasted image 20260211130005

Wed, 11 Feb 2026 12:00:05 GMT

Pasted image 20260211130002

Wed, 11 Feb 2026 12:00:02 GMT

Pasted image 20260211125942

Wed, 11 Feb 2026 11:59:42 GMT

Pasted image 20260211125904

Wed, 11 Feb 2026 11:59:04 GMT

Screenshot 2026-02-11 at 12.57.24

Wed, 11 Feb 2026 11:57:32 GMT

Screenshot 2026-02-11 at 12.50.47

Wed, 11 Feb 2026 11:50:50 GMT

Screenshot 2026-02-11 at 12.45.06

Wed, 11 Feb 2026 11:45:09 GMT

Screenshot 2026-02-11 at 12.44.08

Wed, 11 Feb 2026 11:44:12 GMT

Pasted image 20260211124304

Wed, 11 Feb 2026 11:43:04 GMT

Pasted image 20260211124247

Wed, 11 Feb 2026 11:42:47 GMT

index

Wed, 11 Feb 2026 11:29:08 GMT

NoYesNoYesYesNoNoNoYesNoNoYesYesNoYesNoNoNoNoYesYesNoZoom in with SCROLLCan navigate the Terminal?Familiar with Admin & Superuser?Begin hereTerminal & Files - Basics
Terminal, Git & Github/Terminal - Basics/Terminal - Get StartedGit basicsFamiliar with Terminal & GitHub basics?Github Account created?
Git & Github - First ProjectGithub Account Password Token properly set up?Familiar with Git & Troubleshooting?
Github - Account Creation
Github - Password TokenFamiliar with Git Branches?
Git & Github - Common IssuesIs Git installed?Comfortable with Pull Requests?
Branches - Basics
Terminal, Git & Github/Terminal - Basics/SUDO - Superuser DoGithub Collaboration
Cheatsheet - Pull Requests
Github - Removing Files from GitBasic understanding of User & Technical Stories?
User Stories vs Technical User StoriesComfortable with Git?Basic understanding Agile, Sprints, Roles, MVP, Brainstorming, Planning Poker?
Agile - Workflow
Github - Github Projects WalkthroughBasic understanding of Github Projects?

Pasted image 20260211122646

Wed, 11 Feb 2026 11:26:46 GMT

Pasted image 20260211122620

Wed, 11 Feb 2026 11:26:20 GMT

Pasted image 20260211122242

Wed, 11 Feb 2026 11:22:42 GMT

Pasted image 20260211122100

Wed, 11 Feb 2026 11:21:00 GMT

Pasted image 20260211120442

Wed, 11 Feb 2026 11:04:42 GMT

Pasted image 20260211120339

Wed, 11 Feb 2026 11:03:39 GMT

Pasted image 20260211120310

Wed, 11 Feb 2026 11:03:10 GMT

Pasted image 20260211120151

Wed, 11 Feb 2026 11:01:51 GMT

Pasted image 20260211115819

Wed, 11 Feb 2026 10:58:19 GMT

Screenshot 2026-02-11 at 11.57.27

Wed, 11 Feb 2026 10:57:29 GMT

Pasted image 20260211115527

Wed, 11 Feb 2026 10:55:27 GMT

Pasted image 20260211115359

Wed, 11 Feb 2026 10:53:59 GMT

Pasted image 20260211115312

Wed, 11 Feb 2026 10:53:12 GMT

Pasted image 20260211115232

Wed, 11 Feb 2026 10:52:32 GMT

Pasted image 20260211115208

Wed, 11 Feb 2026 10:52:08 GMT

Pasted image 20260211115152

Wed, 11 Feb 2026 10:51:52 GMT

Pasted image 20260211114633

Wed, 11 Feb 2026 10:46:33 GMT

Pasted image 20260211114613

Wed, 11 Feb 2026 10:46:13 GMT

Pasted image 20260211114555

Wed, 11 Feb 2026 10:45:55 GMT

Pasted image 20260211113551

Wed, 11 Feb 2026 10:35:51 GMT

Pasted image 20260211113455

Wed, 11 Feb 2026 10:34:55 GMT

Pasted image 20260211112607

Wed, 11 Feb 2026 10:26:07 GMT

Pasted image 20260211112542

Wed, 11 Feb 2026 10:25:42 GMT

Pasted image 20260211112516

Wed, 11 Feb 2026 10:25:16 GMT

Github - Github Projects Walkthrough

Wed, 11 Feb 2026 10:23:44 GMT

GitHub Projects is a built-in planning tool where teams can organize tasks, track progress, and manage workflows. It connects directly to issues and pull requests and helps structure work visually. Think of it as: “A project board for your code - where tasks, planning, and progress live together.” GitHub Projects helps teams plan and track work directly next to their code.Visual planning Board and timeline views give a clear overview of progress.Issues as user stories Tasks are connected to real development work.Multiple repositories One project can include issues from several repositories.Clear workflow Custom statuses and fields help structure the process.GitHub Projects keeps planning, tasks, and code in one place.
Step 1
Go to https://github.com Create a new Repository Once created: click Github Projects
Click: New Project link project if you want to connect another Repository Pick Team Planning (great standard)
Optional: When asked about 'bulk import of items', make sure it's checked then create the project (if 0 items are added, this won't matter)
Heads up: it's important to understand user stories / technical stories check them out at: User Stories vs Technical User Stories Step 2 Create a new User-/Technical story
By making it an issue, we connect the Issue-ID with the given User-/Technical Story for ease of access. (You can - at any given time - convert a User-/Technical Story into an issue)
Click: Blank Issue
Decide upon a title, and a clear given instruction so that any person can pick this story up and begin working without confusion.
Navigate into the newly created Story
Within each Story we can effectively add extra details as a complementary to its description.

Kannban Overview Overview of Kannban Board You can at ay given point in time, edit this board, add new columns, colours and more.. To get started, click the + icon
Heads up: Understanding Sprints & Scrum Terminologies is essential and ultimately facilitates the planning and setup of iterations as discussed within their respective internal teams, proceed with this knowledge in hand. Step 3 Navigate to Settings (upper right section of the board)
Navigate towards the Iteration section
Remove all pre-existing iterations, as we will create new ones ahead
Click More Options dropdown, and change to 1-week iteration
This is essentially setting our sprint to be exactly a week long In this case we prepare 4 sprints (1 month)
Make sure you click SAVE Navigate to the iterationtab and click one of the stories there
You can now assign relevant storiesto current iterative sprint
NOTE: Only light planning for future sprints Success Next step is to get started with Agile workflows, get started! Using GitHub Projects with Issues and Sprints gives structure to your development work. It helps you: Turn ideas into clear, trackable tasks Plan work in focused sprint cycles Collaborate transparently as a team Deliver value step by step instead of all at once It moves you from “coding randomly” to working like a real development team.
Back to Overview: Developer Fundamentals

Screenshot 2026-02-11 at 11.03.41

Wed, 11 Feb 2026 10:03:43 GMT

Screenshot 2026-02-11 at 11.03.24

Wed, 11 Feb 2026 10:03:27 GMT

Screenshot 2026-02-11 at 11.00.10

Wed, 11 Feb 2026 10:00:15 GMT

Screenshot 2026-02-11 at 10.58.00

Wed, 11 Feb 2026 09:58:03 GMT

Screenshot 2026-02-11 at 10.55.54

Wed, 11 Feb 2026 09:56:31 GMT

Screenshot 2026-02-11 at 10.54.38

Wed, 11 Feb 2026 09:54:41 GMT

Screenshot 2026-02-11 at 10.53.46

Wed, 11 Feb 2026 09:53:48 GMT

Screenshot 2026-02-11 at 10.41.57

Wed, 11 Feb 2026 09:42:00 GMT

Screenshot 2026-02-11 at 10.41.43

Wed, 11 Feb 2026 09:41:46 GMT

Screenshot 2026-02-11 at 10.41.27

Wed, 11 Feb 2026 09:41:30 GMT

Screenshot 2026-02-11 at 10.41.11

Wed, 11 Feb 2026 09:41:15 GMT

Screenshot 2026-02-11 at 10.40.59

Wed, 11 Feb 2026 09:41:02 GMT

Screenshot 2026-02-11 at 10.39.25

Wed, 11 Feb 2026 09:39:28 GMT

Screenshot 2026-02-11 at 10.37.38

Wed, 11 Feb 2026 09:37:42 GMT

Screenshot 2026-02-11 at 10.35.51

Wed, 11 Feb 2026 09:35:56 GMT

Github_Projects_Guide_Board_Overview

Wed, 11 Feb 2026 09:29:10 GMT

Github_Projects_Guide_3_user-tech-story

Wed, 11 Feb 2026 09:28:00 GMT

Screenshot 2026-02-11 at 10.24.14

Wed, 11 Feb 2026 09:24:17 GMT

Screenshot 2026-02-11 at 10.23.17

Wed, 11 Feb 2026 09:23:20 GMT

Github_Projects_Guide_2_type

Wed, 11 Feb 2026 09:15:38 GMT

Github_Projects_Guide_1_tab

Wed, 11 Feb 2026 09:11:53 GMT

Pasted image 20260211100519

Wed, 11 Feb 2026 09:05:19 GMT

Github - Removing Files from Git

Fri, 23 Jan 2026 20:40:25 GMT

Sometimes a file is gone locally.. but still exists on GitHub or GitHub Pages. This usually happens after renaming or deleting files. In this section you will learn: how to check what Git is actually tracking, and how to remove a file so it disappears online as well. You create and push a file to GitHub. You rename or delete the file locally. You push again. The old file still exists online. This is confusing.. but very common. Git tracks files, not folders Deleting or renaming locally does not always update Git automatically GitHub only shows what exists in the published branch Prerequisites Git installed locally A GitHub repository Basic Terminal knowledge Step 1 mkdir git-remove-file-demo cd git-remove-file-demo git init echo "First version" > page.html git add . git commit -m "Add initial file" Push the project to GitHub. Step 2 Rename the file without using Git: mv page.html index.html git add . git commit -m "Rename file locally" git push Do not fix anything yet. Step 3 git ls-files Filter the result: git ls-files | grep html This shows what Git still knows about. Step 4 If the old file appears in git ls-files, remove it: git rm page.html git commit -m "Remove old tracked file" git push The file will now disappear from GitHub. If a file exists online, it exists in the branch GitHub publishes. Deleting a file locally is not enough.Renaming files like this:mv old.html new.html Instead, use:git mv old.html new.html This allows Git to understand the change correctly.Success Well done! You now know how to remove files from GitHub properly — even when they refuse to disappear. Documentation git ls-files
git rm
Back to Overview: Developer Fundamentals

Terminal - Get Started

Fri, 23 Jan 2026 20:36:35 GMT

“Terminal - Workflow abstract.png” could not be found. The Terminal (sometimes called command line or shell) is a way to control your computer with text commands instead of clicking. It lets you navigate, create files/folders, and run programs directly. Think of it as: “Talking to your computer in its own language, step by step.” Open the Terminal Windows: Press Win + R, type powershell, hit Enter Mac: Press Command + Space, type Terminal, hit Enter Linux: Press Ctrl + Alt + T Navigate to a folder (cd = change directory). List files (ls or dir). Create or remove files/folders. Check where you are (pwd).
This helps you move around and manage your project directly from text commands!Tip Windows vs Mac/Linux: dir (Windows) ≈ ls (Mac/Linux) Most other commands are very similar across systems. The Terminal is your direct connection to the computer: “I want to manage my files and projects quickly, without clicking through folders.” Much faster for development tasks. Works the same across projects (portable knowledge). Often the only way to use tools like Git, Docker, or Node.js. Gives more control and visibility than the file explorer alone.
Windows: Open PowerShell (search in Start menu). Mac: Use COMMAND + SPACE Search for Terminal app. Linux: Use **Ctrl + Alt + T** to open a Terminal.
Navigating Folders Move into a folder: cd my-folder Move one step back: cd .. Move into your home directory: cd ~ Show where you are: pwd # Mac/Linux Get-Location # Windows PowerShell Navigation tips Go up one folder (parent): cd .. Go back to previous location: Mac/Linux: cd - Windows PowerShell: Pop-Location Viewing Files Show files in current folder: ls # Mac/Linux dir # Windows Show hidden files: ls -a Creating Files & Folders Create a new file: touch file.md # Mac/Linux New-Item file.md # Windows PowerShell Create a new folder: mkdir test Remove an empty folder: rmdir test Remove a file or folder (force): rm -rf test # Mac/Linux Remove-Item test -Force -Recurse # Windows PowerShell Warning Be careful with delete commands (rm -rf on Mac/Linux or Remove-Item -Force on Windows). They skip the recycle bin and permanently erase files. Working in the terminal becomes much faster once you know a few shortcuts. These small tricks help you stay efficient while navigating and managing files. Clear Text Mac/Linux: clear Windows: cls Reuse Commands Press ↑ / ↓ to cycle through previous commands (Mac/Linux only) run last command again with: Autocomplete Start typing, press Tab → fills in the file/folder name automatically Cancel a Running Command Works everywhere: Ctrl + C Success YOU DID IT! Practice navigating, creating, and deleting files with these commands. Once you’re comfortable, you’ll be ready to use the Terminal for Git, programming, and automation. Unsure what to do next?
Click here and go to the next step: Developer Fundamentals Documentation
Windows PowerShell: https://learn.microsoft.com/en-us/powershell/
Mac/Linux (Bash): https://www.gnu.org/software/bash/manual/
Back to Overview: Developer Fundamentals

Github - Password Token

Fri, 23 Jan 2026 20:31:32 GMT

A Personal Access Token (PAT) is a secure alternative to your password when pushing or pulling code from GitHub. Since August 2021, GitHub no longer allows normal account passwords for Git operations. Think of it as: “Your personal access key that Git uses instead of your GitHub password.” Generate a Personal Access Token in GitHub. Store it securely (password manager or note). Use it instead of your password when Git asks for credentials. This ensures secure access between your local Git client and GitHub. More secure than passwords Required for all GitHub operations over HTTPS Lets you control exactly what the token can do (scopes/permissions) Tokens can expire — keeping your account safer A GitHub account Git installed locally Basic Terminal knowledge Step 1
Go to GitHub Settings Select Developer settings → Personal access tokens → Tokens (classic) Click Generate new token Step 2 Give your token a name (e.g. “Laptop-Git”) Set an expiration date Choose scopes (permissions): repo (full control of private/public repos) workflow if you’ll use GitHub Actions Generate the token Step 3 Copy the token and store it safely (password manager, notepad, etc.) ⚠️ GitHub will not show it again after you close the page! If lost, you must generate a new one. Step 4 Next time you push or pull, Git will ask for credentials (we'll talk more about what this means in future tutorials): Username: your GitHub username Password: paste your token Credential Manager To avoid pasting the token every time: On Mac/Linux → use git-credential-manager On Windows → Git automatically uses the Windows Credential Manager “Authentication failed” Token expired → generate a new one. Wrong scopes → recreate token with repo access. Lost your token? You cannot recover it. Delete the old one and generate a new token. Multiple tokens It’s okay to have one per device (Laptop, Work PC, etc.). Success YOU DID IT! You now have secure access to GitHub from your computer. Next step: push your first project confidently using your token! Documentation
Managing your personal access tokens
Git Credential Manager
Back to Overview: Developer Fundamentals

Git & Github - First Project

Fri, 23 Jan 2026 20:18:56 GMT

Git is a version control system.. it lets you track changes in your code over time. GitHub is an online platform where you can store Git repositories, collaborate, and share your projects. Think of it as: “Git saves your project’s history, GitHub makes it easy to share that history with others.” Initialize a Git repository in your project (git init). Add files you want Git to track (git add). Commit changes with a message (git commit). Push your commits to GitHub (git push).
This ensures your code history is saved locally and synced to GitHub.With Git & GitHub you can: Keep a history of changes (never lose work). Collaborate with teammates (branches, pull requests). Roll back to an earlier version if something breaks. Work safely on new features without touching stable code.

Install Git here (git --version <-- typing this in the Terminal will show it as installed) If this doesn't work, make sure you restart the computer! A GitHub account A project folder ready Github Tokens setup Basic Terminal knowledge
Before we publish anything, we need a repository (repo) on GitHub.. this will be the “home” for your project.Step 0 Create Repository
Go to GitHub In the top-right corner, click the +, Create New and choose New repository
Name your repo (e.g. my-first-repo) Choose visibility: Public (anyone can see it) Private (only you and collaborators) Important: Leave “Add a README” unchecked (we want an empty repo to push to) Click Create repository Now let’s make something simple that we’ll upload to GitHub.Step 1 Create Project Folder Create an empty folder for the project and add a file to track. Mac / Linux (Terminal): mkdir my-first-repo cd my-first-repo echo "This is my backup." > my-backup.txt ls Windows (PowerShell): mkdir my-first-repo cd my-first-repo echo "This is my backup." > my-backup.txt dir You should now see a file called my-backup.txt in the folder. Before we begin.. Navigate to your project within the terminal Always make sure you’re in your project’s root directory before running Git commands. If you’re in the wrong place, you might accidentally publish sensitive files. Check your current location with: pwd If you accidentally initialized a Git repository and want to remove it, see the bottom section for more information. Step 2 Inside your project folder: git init This creates a hidden .git folder where Git tracks your project’s history. Verify type ls -a to verify the existence of the .git folder Git Status At any step, you can run git status to see the current state of your repository. This shows which files are staged, unstaged, or if there’s anything left to commit. Step 3 Add all files in your project: git add . Or add a specific file: git add my-backup.txt Step 4 Save your changes with a message: git commit -m "Initial commit" Add a title + description: git commit -m "Fix: login validation" -m "Added null-check and proper error handling" Step 5 First, connect your local repo to GitHub: git remote add origin https://github.com/your-username/my-first-repo.git Then push your code: git push -u origin main After the Initial Setup That first push with git push -u origin main also sets up the connection, so in the future you only need: git add . git commit -m "Your message" git push From now on, your workflow is much simpler. Accidental git init If you accidentally initialized a Git repository and want to remove it, delete the hidden .git folder: rm -rf .git This completely removes Git tracking from the project. This will remove all local commits therefore it is recommended to perform a project backup! Success YOU DID IT! Practice creating a repo, adding files, committing, and pushing to GitHub. Next step: learn branches and pull requests for teamwork! Documentation
Git Official Docs
GitHub Docs
Back to Overview: Developer Fundamentals

Terminal - Flow Diagram

Fri, 23 Jan 2026 16:00:13 GMT

Search: TerminalSearch: TerminalOpen TerminalnavigateList directoriesYESNOTerminal - GET STARTEDdir Are you using Mac or Linux?cd ~/Desktop ls Terminal - Linux os png.pngTerminal - Mac os png.pngCommand + Space Goal: Navigate using TerminalIn some cases the name 'Desktop' is localized. Example: bash cd ~/SkrivbordCTRL + ALT + T Win + R
Or: Win + X → choose Windows Terminal (or PowerShell)Terminal - Windows os png.png

Branches - Basics

Fri, 23 Jan 2026 15:30:01 GMT

A branch in Git is basically a separate line of development. You can work on new features or fixes without touching the main codebase Think of it as: “I’ll create a copy of the project at this point in time and make changes there, so the main branch stays safe.”
You create a branch for a new feature or bugfix. You make commits only in that branch. You push it to GitHub. Later, you can merge it back into main through a Pull Request.
This ensures that experiments or changes don’t break the stable version!Tip Use branch naming conventions like feature/add-login, bugfix/fix-validation, or hotfix/security-patch. This makes collaboration and tracking much clearer. A branch is really just a safe workspace: “I want to try something new without messing up main.” Keeps main clean and stable. Makes it easy to test ideas or fix issues independently. Supports parallel teamwork (multiple devs working on different features at the same time). Provides a history of changes tied to each feature or fix.
main → always the stable production-ready code feature branches → for new features bugfix branches → to solve bugs hotfix branches → urgent fixes on main (sometimes merged with bugfix) develop branch (optional) → staging ground before merging into main
Git installed locally A GitHub Repository Basic Git Knowledge Example Create a new branch git branch new-feature Switch to it git checkout new-feature Work on your code and commit changes git add . git commit -m "Add new feature" Push to GitHub git push -u origin new-feature Create new branch & Switch: Shortcut git checkout -b new-feature creates + switches branch Example Show all branches: $ git branch Delete a local branch: $ git branch -d branch-name Delete a remote branch: $ git push origin --delete branch-name Warning When working in a team, creating a branch locally does not make it visible to others. If Person A creates a branch called feature/test-A and pushes it, Person B won’t see it until they fetch the latest changes. To view all branches (both local and remote), run: git branch -a Success YOU GOT IT! Play around with creating, switching, and deleting branches to get comfortable. Combine this with Pull Requests and Issues to create a professional Git workflow.
Documentation Read more about Branches at Git’s official documentation: https://git-scm.com/book/en/v2/Git-Branching-Branches-in-a-Nutshell
Back to Overview: Developer Fundamentals

Terminal & Files - Basics

Fri, 23 Jan 2026 15:30:01 GMT

This section focuses on creating, editing, reading, and filtering files directly from the command line.. without leaving the terminal. Info By the end of this section, you will be able to: Create files and folders Edit files using a terminal-based editor View file contents Filter output using grep Files can be created directly from the terminal. Example Create a new file: touch notes.md # Mac / Linux New-Item notes.md # Windows PowerShell Tip If the file already exists, it will not be overwritten. You don’t need a graphical editor to change files. Files can be edited directly from the command line. Example Open a file using nano: nano notes.md Using nano Type to edit Save: Ctrl + O → Enter Exit: Ctrl + X Info nano is beginner-friendly, but not guaranteed on all systems. If nano is unavailable: Mac / Linux: vi notes.md Windows PowerShell: notepad notes.md These editors are launched from the terminal, even if they look different. Sometimes you only want to read a file. Example Show file contents: cat notes.md Example View long files (scrollable): less notes.md Why use less Scroll with arrow keys Quit with q Safer for large files than cat grep lets you filter text output and show only what matches. Example Search for text inside a file: grep "error" notes.md Example Filter command output using a pipe: ls | grep ".md" Tip Think of grep as: “Only show me lines that contain this.” Common options Ignore case: grep -i "error" notes.md Show line numbers: grep -n "error" notes.md Example A common workflow might look like this: touch notes.md nano notes.md cat notes.md ls | grep ".md" Each step builds on the previous one. Success You can now: Work with files without leaving the terminal Inspect and search text efficiently Use tools that appear everywhere in development These skills are used constantly when working with code, logs, and servers.
Back to Overview: Developer Fundamentals

User Stories vs Technical User Stories

Fri, 23 Jan 2026 15:30:01 GMT

A User Story describes what a user wants and why. It focuses on value, not implementation. Think of it as: “What problem are we solving for the user?” Identify a user Describe what they want Explain why it matters Keep it non-technical Add acceptance criteria (how we know it’s done) Tip Rule: If a non-developer can’t understand it, it’s probably too technical. As a I want So that Example As a student I want to submit my assignment online So that I don’t have to email files to my teacher Example 2 As a teacher I want to see which students have submitted their assignment So that I can quickly follow up with those who haven’t Example 3 As a user I want to reset my password So that I can regain access if I forget it

Example: User & Technical Stories Example - Flow Diagram Acceptance Criteria define what must be true for the story to be complete. Example The student can upload a file The system confirms successful submission The teacher can view the submitted assignment A Technical User Story describes technical work needed to support the system. It does not represent direct user interaction. Think of it as:
“What must exist under the hood for user stories to work?” Describes system behavior Focuses on infrastructure, security, or architecture Is written for developers Supports one or more user stories Has clear technical acceptance criteria Info Technical User Stories often don’t have a visible “user” — but they are still critical. As a I want So that Example As the system I want to validate uploaded file types So that only safe and supported files are stored Example 2 As the system I want to hash user passwords before storing them So that stored credentials are protected if the database is compromised Example 3 As a developer I want to add logging for failed login attempts So that security issues and abuse can be detected

Example: User & Technical Stories Example - Flow DiagramExample Only .pdf and .docx files are accepted Invalid file types are rejected with an error File validation happens before storage Errors are logged for debugging Success User Stories describe what users need Technical User Stories describe how the system supports it “User Story vs Technical Story - Flow.png” could not be found.Tip If you remove all technical terms and the story still makes sense → it’s a User Story If removing technical terms breaks the meaning → it’s a Technical User Story
Back to Overview: Developer Fundamentals

Git & Github - Common Issues

Fri, 23 Jan 2026 15:30:01 GMT

Sometimes GitHub already has commits (like an auto-generated README) while your local project has its own commits. When you try to push, you may see: ![rejected] main -> main (non-fast-forward) error: failed to push some refs to https://github.com/somegithub/somerepository This means your local and remote histories diverged..
Notice that the divergion happened at 'B'.. meaning that the top row is ahead by 'C' Solution Why this happens: Your local branch and the remote branch have different commits. Git refuses to overwrite history unless you merge them. First fetch and allow for unrelated histories: git pull origin main --allow-unrelated-histories Resolve any conflicts (e.g., in README.md). Stage and commit the resolution: git add . git commit -m "some-commit-message-here" Push again: git push origin main Success YOU DID IT! Practice creating a repo, adding files, committing, and pushing to GitHub. Next step: learn branches and pull requests for teamwork! “I committed to the wrong branch” Forgetting to create/switch to a feature branch before working. Fix: use git checkout -b early, or git switch -c. “I deleted files accidentally and Git removed them” Git tracks deletes as well. Fix: restore with git checkout -- filename or git restore filename. “My files are ignored / not showing up” Usually caused by .gitignore catching them. Merge conflicts Happens when two people change the same line in a file. Fix: manually edit, then git add and git commit. “Detached HEAD state” Happens when you checkout a specific commit instead of a branch. Fix: create a new branch from that commit. “Accidentally pushed secrets” (API keys, passwords) Removing them isn’t just deleting — you may need to rewrite history (git filter-repo) or rotate keys. “I want to undo my last commit” git reset --soft HEAD~1 (keep changes staged) git reset --hard HEAD~1 (discard changes) Force push mistakes Overwriting remote history by accident (git push --force). Can wipe out teammates’ work. Cloning into the wrong folder Ending up with nested repos (myrepo/myrepo). “I can’t pull because I have local changes” Fix: commit or stash before pulling. Different local vs remote histories (your exact case) Non-fast-forward errors, diverged timelines. Forgot to set upstream branch First push fails → need git push -u origin main. Permission denied (publickey) SSH key not set up properly. Repository not found / 403 error Wrong URL or missing permissions. Large file rejection GitHub blocks files >100MB. Needs Git LFS or different approach. Documentation
Git Official Docs
GitHub Docs
Back to Overview: Developer Fundamentals

Github - Account Creation

Fri, 23 Jan 2026 15:30:01 GMT

GitHub is an online platform where developers can store code, track changes, and collaborate. It builds on top of Git (version control) and makes teamwork much easier. Think of it as: “A home for your projects - where code, history, and collaboration live together.” GitHub is the world’s most popular platform for version control and collaboration. Industry standard → most companies and open-source projects use it. Collaboration → easy to share code, review changes, and work in teams. History & backup → every version of your project is saved. Integrations → connects with tools like Docker, CI/CD, and cloud providers. Career value → almost every developer is expected to know GitHub basics.
Example
Go to https://github.com Click Sign up Choose a username, email, and password Verify your email Security GitHub now requires Personal Access Tokens instead of passwords when pushing code. Don’t worry.. we’ll cover how to create and use tokens later. Create a simple repo from the web interface. Add a README (your project’s introduction). Browse around Issues, Pull Requests, and the Project tab. Creating a GitHub account is your entry ticket into modern software development. It’s the first step towards: Contributing to real-world projects Building a professional portfolio Learning how developers collaborate globally Success Once you have a GitHub account, you’re officially part of the developer world! Next step: Install Git locally and connect your first project to GitHub. Documentation
GitHub Sign Up
Getting Started with GitHub
Back to Overview: Developer Fundamentals

SUDO - Superuser Do

Fri, 23 Jan 2026 15:30:01 GMT

sudo stands for “superuser do”. It lets you run commands with administrator (root) privileges. This is mostly for Mac & Linux however, Administrator rights are equally as common on Windows. (look at the bottom page) Think of it as: “I need permission to do this, please act as the system admin.” Some commands affect the whole system (like installing software, changing protected files, or starting services). Normal users don’t have the rights to do this. Using sudo ensures you don’t accidentally break things unless you really mean to. Example:sudo apt-get update # Linux package update sudo rm -rf /protected-folder When you type your password after sudo: You won’t see any * or dots — it looks like nothing is happening. But the characters are being recorded in the background. This is a security feature (so nobody can look over your shoulder and see how long your password is). Just type it normally and press Enter.Warning Use sudo carefully. It gives you full control over the machine — including the power to delete critical system files. sudo across systems macOS / Linux Use sudo to run commands as administrator (root). Example: sudo apt-get update # Linux sudo nano /etc/hosts # macOS/Linux You’ll be asked for your password (nothing shows when typing — this is normal). Windows (PowerShell) There is no sudo. Instead, you must run PowerShell as Administrator (right-click → “Run as administrator”). Some commands require elevated privileges, but you don’t prefix them with sudo. Remember: use sudo (or admin mode) only when necessary.. it gives you full system power, including the ability to break things! Back to Overview: Developer Fundamentals

Cheatsheet - Pull Requests

Fri, 23 Jan 2026 15:30:01 GMT

A pull request (PR) is basically a request to merge code from one branch into another branch (usually into main or develop). *You take changes from one branch and combine them into another* Think of it as: “Hey team, I finished a piece of work on my branch. Please review it before we add it to the main project.” You create a branch for a feature (or bugfix) You push your changes to GitHub You open a PR from your branch → into main Reviewers check your code (comment, suggest changes, approve) When approved, it gets merged into the main codebase
This ensures that our main branch stays stable!Feedback can lead to rejection Although the image showcase 'discussion of feedback' then an immediate merge. It oftentimes is rejected due to: code quality, bugs, security issues, performance etc.. When rejected, you won't be allowed to merge. Tip Tools such as GitHub Projects, together with issues and user stories, provide structure and improve communication, leading to a more efficient and higher-quality workflow. A Pull Request (PR) is really just a formal proposal: “I’d like to merge my branch into main. Here are the changes. Please review.” Keeps main stable (only reviewed code gets in). Allows discussion before merging. Keeps a history of why and how changes were made. Connects to Issues/Project boards so work is traceable.
Sometimes your code isn’t ready to merge yet, but you still want feedback. That’s when you can open a Draft Pull Request: Shows clearly that the work is still in progress. The green “Merge” button is disabled until you mark it Ready for review. Useful for early feedback, team visibility, and testing.
Open a pull request and pick what best suits you A Github Account A Github Repository Basic Git Knowledge A local Project that is initialized with $ git init Example Create a new branch with $ git branch new-branch-name-here Add faulty code to the project $ git add . $ git commit -m "Initial Commit" $ git push With the bad code pushed to the branch, we'll now perform the Fix! Here's the example of my codeIMG #1 - Service Logic
IMG #2 - Controller Endpoint w/o Validation
Example Navigate to your Github Repository Within the Main branch there's a Compare & Pull Request for your information!
In this example we'll go with an ordinary Pull Request Fill in the Description, click Create pull request
Review, discuss and comment
In this example, i'm adding a simple comment to play pretend in a group setting where we would want to add constructive feedback and suggest changes Add a reply to the comment
Post and Publish, now merge
Success YOU MADE IT! Make sure you try this out a couple of times and familiarize yourself with other tools such as collaborating with Pull Requests and Issues! For example, say you open up an issue #12, you could in a git commit message link to an issue using $ git commit -m "Fix: Security Issues in Validation (#12) ".
Documentation Read more about Pull Requests at Github's official documentation: https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/proposing-changes-to-your-work-with-pull-requests/about-pull-requests
Back to Overview: Developer Fundamentals

Developer Fundamentals

Fri, 23 Jan 2026 14:55:13 GMT

NoYesNoYesYesNoNoNoYesNoNoYesYesNoYesNoNoYesYesYesNoZoom in with SCROLLCan navigate the Terminal?Familiar with Admin & Superuser?Github Account created?Github Account Password Token properly set up?Terminal, Git & Github/Terminal - Basics/Terminal - Get Started
Terminal & Files - BasicsIs Git installed?
Terminal, Git & Github/Terminal - Basics/SUDO - Superuser DoFamiliar with Git & Troubleshooting?
Github - Account Creation
Github - Password TokenComfortable with Pull Requests?Familiar with Git Branches?
Git & Github - First Project
Git & Github - Common Issues
Branches - Basics
Cheatsheet - Pull RequestsBegin hereGit basicsFamiliar with Terminal & GitHub basics?Basic understanding of User & Technical Stories?Basic understanding of GitHub Issues?Basic understanding of Clear Documentation
User Stories vs Technical User StoriesGithub CollaborationComfortable with Git?

Terminal Fundamentals

Fri, 23 Jan 2026 13:34:49 GMT

Terminal & Files - icon

Fri, 23 Jan 2026 13:21:17 GMT

Screenshot 2026-01-23 at 11.07.02

Fri, 23 Jan 2026 10:07:07 GMT

Screenshot 2026-01-23 at 11.04.34

Fri, 23 Jan 2026 10:04:37 GMT

User & Technical Stories Example - Flow Diagram

Fri, 23 Jan 2026 10:04:30 GMT

Online Shop - User Stories ExampleOnline Shop - Technical Stories ExampleAdd to CartBrowse ProductsOnline Shop As a customer I want to add products to a basket So I can buy more than one item As a customer I want to see products So I can choose what to buy Online Shop Payment As a customer I want to pay for my basket So I can complete my purchase Browse Products As the system I want to store selected products in a cart So the user’s choices persist between pages As the system I want to fetch products from a database So products can be displayed to the user buy Add to CartPayment As the system I want to process payments securely So orders can be completed safely

Screenshot 2026-01-23 at 11.03.04

Fri, 23 Jan 2026 10:03:10 GMT

User & Technical Stories - Technical Story

Fri, 23 Jan 2026 09:44:04 GMT

User & Technical Stories - User Story

Fri, 23 Jan 2026 09:40:43 GMT

Branches

Fri, 23 Jan 2026 09:34:04 GMT

Terminal - Git Branch - Flow Diagram simplified.png

Fri, 23 Jan 2026 09:33:03 GMT

Git Branch Simplified - Flow Diagram

Fri, 23 Jan 2026 09:31:51 GMT

$ git clone URL$ git fetchBranch WorkflowGitHubLocal PCBranch AvailableRepositoryOthers can now see branchCreate BranchCommit WorkPush BranchFetchClone Repository$ git checkout -b NAME$ git commit -m "TITLE" -m "Description"

Git Branch - Flow Diagram

Fri, 23 Jan 2026 09:25:45 GMT

$ git branch new-branch$ git push -u origin new-branch$ git fetchOther members won't be able to see these changes unless fetched $ git add . $ git commit -m "initial commit"CollaboratorBranch Workflow with commandscommit #125Discussion - Group.pngPush the newly created branch. The branch is now available to others within the team
Clone Github RepositoryGithub Account - Circle.pngCommit work to new branch$ git branch -a Shows branches both locally and remotelycommit #124Create new Branch

Git - Flow Diagram TBD

Fri, 23 Jan 2026 09:16:57 GMT

navigate to project $ cdgit add .git initgit remote add origin LINK-TO-REPOgit commit -m "Initial Commit"git push -u origin mainFrom Terminal -> Project -> Pushing to GithubCreate Repository on Github.comCreate new File within ProjectCreate Folder/Project locallyInitialize Git RepositoryAdd New FilesAdd RemoteRepeat process From now on, git push is enoughCommits should be descriptive. What did we Add, Fix or remove?PublishAdd Commit Description

Pull Request - Flow Diagram

Fri, 23 Jan 2026 09:16:24 GMT

Collaborator$ git branch new-branchDiscuss FeedbackPull Request - WorkflowClone Github RepositoryCreate new BranchGithub Account - Circle.pngcommit #124commit #125
Create Pull RequestDiscussion - Group.pngMain Merge Changes

Git & Github - First Project Workflow

Fri, 12 Sep 2025 11:46:36 GMT

Git & Github - Repository Creation

Fri, 12 Sep 2025 11:22:02 GMT

Git & Github - Token Password

Fri, 12 Sep 2025 11:05:28 GMT

Git & Github - Industry Standard

Fri, 12 Sep 2025 11:01:19 GMT

Git & Github - Teamwork puzzle

Fri, 12 Sep 2025 11:00:39 GMT

Git & Github - Separate Timelines

Thu, 11 Sep 2025 13:47:04 GMT

Git & Github - Benefits diagram

Thu, 11 Sep 2025 13:31:37 GMT

Git & Github - Workflow

Thu, 11 Sep 2025 13:27:17 GMT

Git & Github - Git + Github png

Thu, 11 Sep 2025 13:26:43 GMT

Git & Github - Rejected Error

Thu, 11 Sep 2025 13:20:52 GMT

Terminal - Navigate - Flow Diagram

Thu, 11 Sep 2025 11:40:09 GMT

Terminal - Windows os png

Thu, 11 Sep 2025 11:19:37 GMT

Terminal - Linux os png

Thu, 11 Sep 2025 11:18:26 GMT

Terminal - Mac os png

Thu, 11 Sep 2025 11:15:50 GMT

Terminal - Sudo think png

Thu, 11 Sep 2025 09:10:43 GMT

Terminal - Sudo info png

Thu, 11 Sep 2025 09:09:36 GMT

Terminal - icon png

Thu, 11 Sep 2025 09:01:39 GMT

Terminal - Git Branch - Flow Diagram

Thu, 11 Sep 2025 08:53:48 GMT

Git branch - Workflow abstract png

Thu, 11 Sep 2025 08:09:33 GMT

Git branch - Benefits

Thu, 11 Sep 2025 08:04:51 GMT

Git Branch - Workflow

Thu, 11 Sep 2025 07:57:58 GMT

Git Branch - What it is

Thu, 11 Sep 2025 07:57:20 GMT

Pull Request - Merge

Tue, 09 Sep 2025 15:28:24 GMT

Pull Request - Quote Reply

Tue, 09 Sep 2025 15:22:41 GMT

Pull Request - Adding Comment

Tue, 09 Sep 2025 15:17:29 GMT

Pull Request - Description

Tue, 09 Sep 2025 15:15:18 GMT

Pull Request - Alternatives

Tue, 09 Sep 2025 15:12:02 GMT

Shaking Hands

Tue, 09 Sep 2025 15:11:22 GMT

Pull Request - Github Showcase 2

Tue, 09 Sep 2025 15:05:59 GMT

Pull Request - Github Showcase

Tue, 09 Sep 2025 15:00:33 GMT

Code Example - part 2

Tue, 09 Sep 2025 14:43:59 GMT

Code Example - part 1

Tue, 09 Sep 2025 14:43:59 GMT

Pull Request - Flow Diagram image

Tue, 09 Sep 2025 12:57:23 GMT

Discussion - Group

Tue, 09 Sep 2025 12:53:48 GMT

Github Account - Circle

Tue, 09 Sep 2025 12:41:59 GMT

Pull Request - Overview

Tue, 09 Sep 2025 11:39:07 GMT