roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Answer Linux interview questions like someone who has run servers, not only logged into them. Covers the shell and scripting, processes and services, storage and packages, networking, and troubleshooting.
714 of 714 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 714 new. 0 cut, outside your plan.
A developer loop rarely sets aside time for Linux by name; the questions arrive inside another round. Backend and data candidates meet it when a deployment or debugging conversation reaches the host. DevOps, SRE, platform and systems administrator loops usually give it a dedicated round, often run as a live troubleshooting scenario: a server is slow, a disk is full, a service is running and nobody can reach it. The interviewer plays the machine and answers whichever command you ask for. Those scenarios are built from mechanisms. `df` reports a full disk that `du` cannot account for, because a deleted log file is still held open by a running process. Writes fail on a filesystem with free space, because it has run out of inodes. Load average reads high on a machine whose CPUs are mostly idle, because Linux also counts processes stuck in uninterruptible sleep on I/O, and those same processes ignore `kill -9` until the call they are blocked in returns. Shell questions are smaller and sharper: why a counter incremented inside a `while read` loop at the end of a pipeline is back to zero afterwards, or why the setuid bit on a shell script does nothing. What separates levels here is how many layers beneath a symptom a candidate can go before the answer runs out. Many early-career answers stop at naming the command that shows the symptom. Stronger candidates say which layer the problem lives in, prove it with the next tool, from `vmstat` and `ss` to `strace`, `perf` or an eBPF probe, and choose a fix that still holds after the next reboot.
Most of what follows is typed at a prompt, so the shell comes first, and [expansion](/topics/lang-bash-variables-expansion) leads it: the quoting, splitting and globbing that rewrite a line before the command sees its arguments decide what an `rm` actually removes. Redirection and pipes follow, the plumbing the plan's later diagnostic one-liners are built from. From there the plan moves through the machine at rest, then in motion. Files come before the rules about them: [the filesystem](/topics/os-linux-filesystem), the logical volumes beneath it, and only then [permissions](/topics/os-linux-permissions), since mode bits, ACLs and capabilities govern objects you already understand. Process Management pairs [processes and signals](/topics/os-linux-processes-signals) with the shell's own [job control](/topics/lang-bash-process-control), because the shell forks for every external command, and the question of where a variable went is usually a question about which child changed it. Boot, Kernel & Services then explains how all of it starts: the [boot chain](/topics/os-linux-kernel-boot) up to the hand-off to PID 1, the move from runlevels to targets, and [systemd](/topics/os-systemd) as the init most current distributions run. The distribution layer comes after that shared ground, opening on [how packages are modeled](/topics/os-linux-service-package-mgmt-package-models) before the package managers and the distribution families themselves. Networking is taken from the host outward, then down through the protocol stack. Network & Remote Access starts with the [kernel's own stack](/topics/os-linux-networking-stack) and its netfilter hooks, then firewalling and remote access. TCP/IP Fundamentals goes beneath it: [TCP](/topics/proto-tcp) down to its retransmission timers, IP addressing and [subnet arithmetic](/topics/proto-cidr-subnet-math), then the small protocols that make a local network work, ending on [tcpdump](/topics/sec-tcpdump) so the protocols can be watched on a real interface. Shell Scripting returns to bash late on purpose. [Strict mode, locking and running unattended](/topics/lang-bash-scripting-practices) assume the exit statuses, signals and systemd units the earlier modules taught. Observing a Live System then gathers the tools that read across those layers, from the stats commands through [strace and perf](/topics/os-tracing-diagnostics) to [eBPF](/topics/os-ebpf). The plan closes on the [container isolation model](/topics/cloud-containers-concepts-isolation), which is the namespaces and cgroups from Process Management assembled into one boundary.
If Linux is a supporting line on a backend or data posting, the questions you will meet sit mostly in the shell, files, permissions and processes. Close to the date, let importance keep only must know: LVM, kernel modules and eBPF rarely reach a developer's round, and what survives the cut leans toward that everyday ground. An SRE, platform or administrator loop is different, because the troubleshooting round can open anywhere. Take the plan end to end under the by topics study order, with a throwaway virtual machine open beside it. Fill a filesystem's inodes with empty files, delete a log that a process is still writing, block your own SSH port with a firewall rule, and find each fault again with the tools from the observation module. Senior candidates get more from that module and the networking pair than from the package managers, since a scenario that ends in a packet capture or a syscall trace is where senior rounds tend to go. Containers appear here only as a kernel mechanism. Building and shipping images, registries and Compose are where the [Docker roadmap](/roadmaps/docker) picks up. Anyone preparing for those loops needs next what a Linux host usually sits inside: delivery pipelines, infrastructure code and orchestrators, which the [DevOps / SRE Engineer roadmap](/roadmaps/devops) takes on.
A developer loop rarely sets aside time for Linux by name; the questions arrive inside another round. Backend and data candidates meet it when a deployment or debugging conversation reaches the host. DevOps, SRE, platform and systems administrator loops usually give it a dedicated round, often run as a live troubleshooting scenario: a server is slow, a disk is full, a service is running and nobody can reach it. The interviewer plays the machine and answers whichever command you ask for.
Those scenarios are built from mechanisms. df reports a full disk that du cannot account for, because a deleted log file is still held open by a running process. Writes fail on a filesystem with free space, because it has run out of inodes. Load average reads high on a machine whose CPUs are mostly idle, because Linux also counts processes stuck in uninterruptible sleep on I/O, and those same processes ignore kill -9 until the call they are blocked in returns. Shell questions are smaller and sharper: why a counter incremented inside a while read loop at the end of a pipeline is back to zero afterwards, or why the setuid bit on a shell script does nothing.
What separates levels here is how many layers beneath a symptom a candidate can go before the answer runs out. Many early-career answers stop at naming the command that shows the symptom. Stronger candidates say which layer the problem lives in, prove it with the next tool, from vmstat and ss to strace, perf or an eBPF probe, and choose a fix that still holds after the next reboot.
Most of what follows is typed at a prompt, so the shell comes first, and expansion leads it: the quoting, splitting and globbing that rewrite a line before the command sees its arguments decide what an rm actually removes. Redirection and pipes follow, the plumbing the plan's later diagnostic one-liners are built from.
From there the plan moves through the machine at rest, then in motion. Files come before the rules about them: the filesystem, the logical volumes beneath it, and only then permissions, since mode bits, ACLs and capabilities govern objects you already understand. Process Management pairs processes and signals with the shell's own job control, because the shell forks for every external command, and the question of where a variable went is usually a question about which child changed it. Boot, Kernel & Services then explains how all of it starts: the boot chain up to the hand-off to PID 1, the move from runlevels to targets, and systemd as the init most current distributions run. The distribution layer comes after that shared ground, opening on how packages are modeled before the package managers and the distribution families themselves.
Networking is taken from the host outward, then down through the protocol stack. Network & Remote Access starts with the kernel's own stack and its netfilter hooks, then firewalling and remote access. TCP/IP Fundamentals goes beneath it: TCP down to its retransmission timers, IP addressing and subnet arithmetic, then the small protocols that make a local network work, ending on tcpdump so the protocols can be watched on a real interface.
Shell Scripting returns to bash late on purpose. Strict mode, locking and running unattended assume the exit statuses, signals and systemd units the earlier modules taught. Observing a Live System then gathers the tools that read across those layers, from the stats commands through strace and perf to eBPF. The plan closes on the container isolation model, which is the namespaces and cgroups from Process Management assembled into one boundary.
If Linux is a supporting line on a backend or data posting, the questions you will meet sit mostly in the shell, files, permissions and processes. Close to the date, let importance keep only must know: LVM, kernel modules and eBPF rarely reach a developer's round, and what survives the cut leans toward that everyday ground.
An SRE, platform or administrator loop is different, because the troubleshooting round can open anywhere. Take the plan end to end under the by topics study order, with a throwaway virtual machine open beside it. Fill a filesystem's inodes with empty files, delete a log that a process is still writing, block your own SSH port with a firewall rule, and find each fault again with the tools from the observation module. Senior candidates get more from that module and the networking pair than from the package managers, since a scenario that ends in a packet capture or a syscall trace is where senior rounds tend to go.
Containers appear here only as a kernel mechanism. Building and shipping images, registries and Compose are where the Docker roadmap picks up. Anyone preparing for those loops needs next what a Linux host usually sits inside: delivery pipelines, infrastructure code and orchestrators, which the DevOps / SRE Engineer roadmap takes on.