Sefism Linux, Terminal and Git Roadmap

What it is

The Linux, terminal and Git roadmap is Sefism's plan for the tools every software job assumes you already know: a Unix shell, the classic text tools, permissions and processes, Git and GitHub, small Bash scripts, and SSH into a server. It is eight stages and about 88 hours of work, and almost all of it is done in a terminal rather than read about.

Each stage lists its topics in learning order, a short explanation of each, a check question to answer without notes, a milestone, a hands-on checklist and a small set of resources with a clear job: follow one of these, practise here, keep this open.

By the end you can:

• Set up a working development machine with a Unix shell, a package manager, Git and an editor, and explain every step you took.
• Find, filter and transform files and text with the shell, pipes, grep, find and jq instead of clicking through folders.
• Use Git and GitHub like a team member: small commits, branches, pull requests, conflict resolution and undoing mistakes safely.
• Write a checked Bash script, schedule it with cron and run it on a small Linux server you reach over SSH with keys.
• Debug a broken environment methodically: read the error, check PATH, permissions, processes, ports and logs.

Pick your computer

The roadmap asks what computer you work on, and the first stage changes to match:

• Windows: WSL 2 with Ubuntu, Windows Terminal as your home, and projects kept inside the Linux file system rather than under /mnt/c.
• macOS: Terminal or iTerm2 with zsh, the Xcode Command Line Tools and Homebrew.
• Linux: choosing a distribution, your terminal and shell, and the difference between system packages, snaps and flatpaks.

From the second stage onwards everyone works in a Unix shell, so the rest of the roadmap is shared. Each version has 66 topics. Windows is the default at /roadmaps/dev-tools/; macOS and Linux have their own pages linked from it.

Who it suits, and who should start elsewhere

It suits university students and early-career engineers who can write some code but freeze when a tutorial says "open a terminal", lose work to Git, or have never logged into a server. It also suits anyone about to start an internship or first job who wants to stop asking teammates how to undo a commit.

If you have not written a program yet, begin with the Programming foundations roadmap; this one assumes you have something to put in a repository. If you already live in the terminal and want to run infrastructure, move on to DevOps and cloud or Platform engineering and SRE.

Time and a weekly plan

The eight stages add up to about 88 hours. Only the first, Set up your machine (6 hours), is a foundation stage you can skim if your setup is already clean. The page converts hours into weeks from the pace you choose: about 20 weeks at 5 hours a week, 15 weeks at 8 hours, or 10 weeks at 12 hours.

A student with 8 hours a week: do the setup in one weekend, then a stage every two weeks or so. The roadmap's advice for the shell stage is to stay in the terminal for a week of normal work, even when clicking would be faster, so do your coursework there too.

Someone working full time with 5 hours a week: two short evenings and one longer weekend session. Use real material from your job (a log, a CSV export, your own repositories) for the text tools and Git stages; it sticks faster than practice files.

Stage by stage

1. Set up your machine (6 hours, foundation)

Get a real Unix shell, a package manager, Git and an editor working. Shared topics cover the terminal, shell and prompt, getting help from the terminal, updating and installing packages, installing and configuring Git, and opening VS Code from the terminal. Milestone: one terminal tab gives you a Unix shell with Git configured, a working package manager, VS Code opening from code ., and a ~/code folder holding a first test repository. The checklist ends with a short setup note listing every tool you installed and how.

2. Shell basics (12 hours)

Paths and moving around, creating, copying, moving and deleting, wildcards and quoting, pipes, redirection and the three streams, environment variables, PATH and "command not found", startup files and aliases, and editing in nano and Vim. Milestone: a log of 20 tasks solved only in the terminal, each with the command and what it did. The checklist includes the first five levels of OverTheWire Bandit.

3. Text tools (10 hours)

cat, less, head and tail, grep, find, sort, uniq, cut and wc, regular expressions, sed, awk, and jq for JSON. Milestone: ten real questions answered from a real log, CSV or JSON file (top error messages, largest files, busiest hour), each with its one-liner.

4. Permissions, processes and packages (10 hours)

Read, write and execute permissions, users, groups, root and sudo, processes and signals, foreground and background jobs, installing developer tools properly, version managers such as nvm and pyenv, and disk space. Milestone: a written audit of your own machine: where each main tool comes from, which language versions are installed and how they are switched, what uses the most disk, and one permission problem you found and fixed.

5. Git fundamentals (14 hours)

How Git stores snapshots, the working tree, staging area and commits, small commits with clear messages, .gitignore, branches, merge and rebase, resolving conflicts calmly and undoing things safely. Milestone: a personal repository with at least 20 meaningful commits across several branches, one merge, one rebase, one resolved conflict and one reverted commit, plus a note on the commands you used. The checklist includes recovering a "lost" commit with git reflog and finishing Learn Git Branching.

6. GitHub and working with others (10 hours)

Remotes, SSH keys for GitHub, GitHub flow, writing a good pull request, giving and receiving review, forks and keeping them in sync, the GitHub CLI, and secrets and account safety. Milestone: two merged pull requests, one to your own repository with a written description and self-review, and one to someone else's project from a fork (documentation fixes count).

7. Shell scripts and automation (12 hours)

Anatomy of a script, failing safely with exit codes and set -euo pipefail, variables and arguments, conditionals and loops, functions, ShellCheck, cron and a dotfiles repository. Milestone: a public dotfiles repository with an idempotent install.sh that passes ShellCheck with no warnings, plus one useful script of your own running from cron and writing to a log.

8. SSH, servers and debugging (14 hours)

SSH and the SSH config file, scp and rsync, setting up a first server safely, tmux, services and logs, curl, network checks for DNS, ping and ports, and a method for debugging your environment. Milestone: a small Linux server you set up yourself with a sudo user, key-only SSH, root and password login disabled, a firewall, a simple site or API checked with curl, your cron script running on it, and a one-page runbook. The stage asks you to set a billing alert first and delete the server when you are done.

Projects that fit

Three projects pull the stages together: dotfiles and a one-command machine setup, a command-line log analyser with a scheduled report, and the capstone, a self-hosted web app on a hardened VPS.

How it works on Sefism

Everything on Sefism is free to learn from, and this roadmap is currently free to add as well. The public page at Linux, terminal and Git shows every stage open for every computer, with its topics, milestones and recommended material.

Adding it to your dashboard costs no credits and does not use up your free first roadmap, so that stays available for another one. Once you add it, it stays yours. On your dashboard you can:

• tick stages off and track your progress, at a pace set by the hours you have each week
• keep the companion Linux, terminal and Git cheat sheet, which comes with the roadmap
• ask Tauseef a question about any stage, or book a 1:1 session if you want to talk your plan through

If you are new, create a free account first.

The companion cheat sheet

The Linux, terminal and Git cheat sheet mirrors the eight stages as chapters, with commands, short examples and the common mistake for each, in Windows, macOS and Linux editions. Keep it open while you work through a stage.

Related on Sefism

• How to learn Git and GitHub properly
• Git: the model behind the commands
• What actually happens between your pull request and production
• How to learn programming with a weak laptop or slow internet
• Library picks used in the stages: The Missing Semester of Your CS Education, Pro Git, Learn Git Branching, OverTheWire: Bandit and ShellCheck
• Related roadmaps: Backend development, Open source and DevOps and cloud

What you can do afterwards

Join a team and be useful from the first week: clone, branch, open clean pull requests, read logs and fix your own environment. You will also have three things to show: a dotfiles repository, a script running on a schedule, and a server you secured and documented.

FAQ

How long does it take to learn Linux and Git? The roadmap is about 88 hours: roughly ten weeks at 12 hours a week, or twenty at 5. Comfort comes from daily use rather than finishing a course.

Do I need to install Linux to follow this on Windows? No. The Windows version uses WSL 2 with Ubuntu, which gives you a real Linux shell alongside Windows.

Is learning the terminal still worth it with AI tools? Yes. The roadmap's tools section suggests explainshell for checking any copied command before you run it, and the companion cheat sheet warns against pasting commands you do not understand, especially with sudo, rm or a pipe.

Do I need to pay for a server? Stage 8 suggests a small VPS or a free-tier instance, with a billing alert set first and the server deleted when you no longer need it.