Red Hat Certified System Administrator (RHCSA)

Exam EX200. Unlike every other cert on this hub, the RHCSA is 100% hands-on: three hours at a real RHEL system performing real tasks — no multiple choice, graded by scripts that inspect your machine's final state. It's the gold-standard proof you can actually administer Linux, and the foundation for RHCE and the whole Red Hat track.

100% hands-on lab 3 hours pass 210/300 $500 USD free retake incl. Valid 3 years
⚡ Open the 1-page Cram Jam sheet

Part 1 — High-Level Overview

What & Why

The RHCSA validates that you can perform the core tasks of a Linux system administrator on Red Hat Enterprise Linux — manage users, storage, file systems, networking, security (SELinux/firewalld), services, and software — with your hands, under time pressure, with only man pages for help. Because it can't be passed by memorizing answers, employers treat it as one of the most credible entry-to-mid-level infrastructure certs anywhere.

The one rule that defines the exam Red Hat's own words: "configurations must persist after reboot without intervention." A working-but-not-persistent config scores zero. Every topic in this guide ends with "…and make it survive a reboot."

⚠️ RHEL 9 vs RHEL 10 — check which exam you're booking

Version fork (2026) The official EX200 page now states the exam is based on RHEL 10. The RHEL 9 version (EX200V9) may still be selectable while it phases out — you choose the version when scheduling, so check before you study. Most community pass reports to date are for RHEL 9. Roughly 85–90% of the content is identical; the differences:
EX200V9 (RHEL 9)EX200V10 (RHEL 10)
Containers✔ Podman objectives (run, systemd services, persistent storage)Removed entirely
Softwarednf + repos (incl. modularity)New "Manage software" category adds Flatpak; dnf modularity dropped
Schedulingat + cronat + cron + systemd timer units
Also in v10—Modify the system bootloader; GPT-only partitioning (MBR dropped)

This guide covers both: everything shared, plus §11 for V9 containers and V10 callouts (Flatpak, timers, bootloader) inline in §7.

Exam at a Glance

AttributeValue
Exam codeEX200 (RHCSA)
FormatHands-on, performance-based lab on live systems — no multiple choice; graded automatically against system state
Duration3 hours (confirm at booking)
Passing score210 / 300 (70%)
Cost$500 USD (varies by country); one free retake included with individual exams (use within 1 year; classroom exams excluded)
DeliveryRemote (boot your own x86_64 PC from a Red Hat live USB, live proctor, compatibility test 2–3 days prior) · testing-center kiosk · classroom after training
Resources allowedNo internet, no notes. man pages, --help, info, and /usr/share/doc ARE available — learn to mine them.
PrerequisitesNone required (RH124 + RH134, RH199, or equivalent experience recommended)
Results / validityEmailed pass/fail + per-category % (usually within hours, officially ≤3 business days) · valid 3 years

→ Deep dive: §1 Exam Details & Format

The Objectives

Red Hat publishes no weightings — every category can appear. The official categories map to this guide's sections:

Official categoryDeep dive
Understand and use essential tools→ §2
Create simple shell scripts→ §3
Operate running systems (boot, processes, journals, services)→ §4
Configure local storage (partitions, LVM, swap)→ §5
Create and configure file systems (xfs/ext4/vfat, NFS, autofs)→ §6
Deploy, configure, and maintain systems (scheduling, services, time, software) +Flatpak/timers/bootloader in V10→ §7
Manage basic networking (nmcli, hostname, firewalld)→ §8
Manage users and groups→ §9
Manage security (firewalld, umask, SSH keys, SELinux)→ §10
Manage containers (podman) V9 only→ §11

Recommended Materials (community consensus)

The consensus stack: Sander van Vugt (book + video + practice exams — "the gold standard," accessed cheaply via O'Reilly ~$49/mo or free through many libraries) → optionally Asghar Ghori's book for depth → a home lab of two VMs on free real RHEL (Developer Subscription, 16 licenses) → drill van Vugt's + Lisenet's (free) practice exams until you finish them cold, under time, with everything surviving a reboot.

→ Full breakdown with sources (§12)

Study Plan (Quick Version)

  1. Build the lab first (day 1): two RHEL VMs. Every hour of study after that is hands-on.
  2. Work the objectives as tasks, not reading: do each one, then reboot and verify — persistence is the exam.
  3. Drill retrieval: re-do tasks from a blank terminal, no notes, using only man pages (exactly the exam conditions).
  4. Mock exams under time: van Vugt's + Lisenet's, full 3-hour blocks, offline. Book when you finish them comfortably with time to spare.

→ Detailed retention-based plan (§13) · ⚡ Cram Jam

Part 2 — Thorough Study Guide

1 · Exam Details & Format

  • You get real systems and a task list. Tasks look like: "Create a 500 MiB logical volume named lvdata in volume group vgdata, format it XFS, and mount it persistently at /data." Scoring scripts then check the final state — how you did it doesn't matter; that it works and persists does.
  • Partial credit exists per task/category, and your results email shows a percentage per objective category — but no explanations. Several test-takers report surprise 0% categories from strict script grading, usually persistence misses.
  • No penalty for breaking things you fix — but an unbootable system at grading time can zero everything. Balance boldness with care around fstab and the bootloader.
  • Remote exam specifics: boot from a Red Hat live USB on your own machine, external webcam for a 360° room scan, single monitor, empty desk (no paper on remote; allowed in person), compatibility test 2–3 days prior. Test-center kiosks avoid all of that — several Redditors call remote "an order of magnitude more stressful."
  • Free retake: individual exam purchases include one retake on a NO PASS/NO SHOW, within 1 year.
The docs are your lifeline Practice answering questions with only man, --help, and /usr/share/doc. High-value man pages with EXAMPLES sections: man semanage-fcontext, man 5 fstab, man 5 crontab, man lvcreate, man 8 mount. Knowing where an example lives is as good as memorizing it.

2 · Essential Tools

Redirection & text processing

  • Redirection: > overwrite, >> append, 2> stderr, &> both, | pipe, 2>&1 merge stderr into stdout.
  • grep -i (case-insensitive) -v (invert) -r (recursive) -E (extended regex) -l (filenames only). Regex anchors ^ $, classes [abc], repetition * +.
  • Classic exam task shape: "Find all lines containing X in file Y and save them to /root/answer" → grep 'X' Y > /root/answer — exact output path matters to the grader.

Files, links, archives, find

  • tar -czf a.tar.gz /etc (z=gzip, j=bzip2, J=xz) · extract tar -xzf a.tar.gz -C /dest · list tar -tf. Compress standalone files with gzip/bzip2, reverse with gunzip/bunzip2.
  • Hard link (ln) = same inode, same filesystem only, survives deleting the original. Soft link (ln -s) = pointer by path, crosses filesystems, breaks if target moves.
  • find /home -user bob -exec cp -p {} /root/found/ \; · find / -perm -4000 (SUID) · -size +100M · -name "*.conf". The -exec … {} \; pattern is a recurring exam task.
  • Permissions: chmod u+x / 754 …, chown user:group, chgrp. Special bits: SUID 4, SGID 2, sticky 1 (e.g. chmod 2770 for a group-collab dir).
  • SSH: ssh user@host, scp file user@host:/path, rsync -av, sftp.

3 · Shell Scripts

  • Start with #!/bin/bash; chmod +x. Inputs: $1 $2 …, all args $@, count $#, exit status $?.
  • Conditionals: if [ "$1" = "start" ]; then … elif … else … fi. Tests: -f file exists, -d dir, -z empty string; numeric -eq -ne -gt -lt. Quote your variables.
  • Loops: for f in /etc/*.conf; do echo "$f"; done · for i in $(seq 1 10) · while read line; do …; done < file.
  • Command output into a script: var=$(command).
  • Typical exam shape: "Write /root/script.sh that takes one argument; if it's foo print X, otherwise print Y" — simple branching + args, nothing exotic. Test your script both ways before moving on.

4 · Operate Running Systems

Boot, targets & the root-password reset

  • Targets: systemctl get-default / set-default multi-user.target (or graphical.target); switch live with systemctl isolate. One-off boot to a target: append systemd.unit=multi-user.target to the kernel line.
  • Root password reset (know this cold — it's usually your first exam task): at GRUB press e → append rd.break to the linux line → Ctrl+X, then:
    mount -o remount,rw /sysroot → chroot /sysroot → passwd root → touch /.autorelabel → exit → exit.
  • Fallback method: append init=/bin/bash instead → mount -o remount,rw / → passwd → touch /.autorelabel → exec /sbin/init. Know both — a GRUB quirk bit at least one live exam-taker.
The #1 reset trap Skip touch /.autorelabel and SELinux contexts on /etc/shadow are wrong after reboot — logins fail and the task scores zero. Remount rw first, autorelabel last, every time.

Processes & tuning

  • top / ps aux --sort=-%cpu to find hogs; kill PID, kill -9 as last resort, pkill name.
  • Priorities: nice -n 10 cmd, renice -n 5 -p PID (lower = more CPU; only root sets negative).
  • Tuning profiles: tuned-adm active · tuned-adm list · tuned-adm profile virtual-guest · tuned-adm recommend. (Ensure tuned is installed/enabled.)

Logs & journals

  • journalctl -u sshd · -b (this boot) · -p err · --since "2026-07-01 09:00" · -f (follow). Classic logs still in /var/log/ (messages, secure).
  • Preserve journals across reboots (a stated objective): mkdir -p /var/log/journal && systemctl restart systemd-journald — or set Storage=persistent in /etc/systemd/journald.conf.

Services

  • systemctl status|start|stop|restart httpd; systemctl enable --now httpd — enable and start in one shot. enable alone does NOT start it; start alone does NOT survive reboot. systemctl mask hard-disables.

5 · Local Storage — Partitions, LVM, Swap

Partitioning

  • parted /dev/sdb mklabel gpt (destroys the table; parted writes immediately — no undo) → parted /dev/sdb mkpart data xfs 1MiB 501MiB → parted /dev/sdb set 1 lvm on.
  • Or fdisk/gdisk interactive (n=new, t=type, w=write). After changes to an in-use disk: partprobe; before formatting a fresh partition: udevadm settle.
  • V10 note: objectives are GPT-only; V9 also listed MBR.

LVM — the exam's bread and butter

  • Stack: PV → VG → LV. pvcreate /dev/sdb1 → vgcreate vgdata /dev/sdb1 (set PE size with -s 16M if asked) → lvcreate -n lvdata -L 500M vgdata.
  • Size flags: -L absolute (500M, 2G); -l extents — and percentages only work with -l (-l 100%FREE).
  • Grow: vgextend vgdata /dev/sdc1 then lvextend -r -L +500M /dev/vgdata/lvdata — the -r resizes the filesystem too (the habit that saves you). Manual FS grow: xfs_growfs /mountpoint (XFS, mounted, takes the mount point) vs resize2fs /dev/… (ext4, takes the device). XFS cannot shrink.
  • Inspect: pvs / vgs / lvs (+ -a -o +devices for detail), lsblk.

Swap

  • mkswap /dev/vgdata/lvswap → swapon /dev/vgdata/lvswap → fstab line: /dev/vgdata/lvswap none swap defaults 0 0 → validate with swapon -a && swapon --show.

6 · File Systems, NFS & autofs

Make & mount persistently

  • mkfs.xfs / mkfs.ext4 / mkfs.vfat on the device or LV.
  • Get the UUID with blkid; fstab entry: UUID=abc-123 /data xfs defaults 0 0 (no quotes around the UUID).
  • Always validate before rebooting: mount -a (errors surface immediately) and findmnt --verify. A bad fstab line drops the system into emergency mode — the classic exam-bricker.

NFS & autofs

  • Manual NFS: mount -t nfs serverb:/share /mnt; persist via fstab with type nfs.
  • autofs (on-demand mounting — a stated objective): dnf install -y autofs nfs-utils && systemctl enable --now autofs.
  • Master map /etc/auto.master.d/shares.autofs: indirect → /shares /etc/auto.shares; direct → /- /etc/auto.direct.
  • Indirect map line: work -rw,sync serverb:/shares/work (mounts as /shares/work). Direct map line uses the full path.
  • The wildcard home-dir classic: * -rw serverb:/home/guests/& — * matches the key, & substitutes it. Don't pre-create indirect mount dirs; restart autofs after edits.

Permissions problems & collaboration dirs

  • Group-collab dir recipe: mkdir /shared && chgrp devs /shared && chmod 2770 /shared — the SGID bit (2) makes new files inherit the group.
  • ACLs when ugo/rwx isn't enough: setfacl -m u:bob:rw- file, default ACLs on dirs setfacl -m d:u:bob:rw /dir, inspect with getfacl.
  • Diagnosing "permission denied": check ownership, mode, ACL mask, and SELinux context (§10) — in that order.

7 · Deploy, Configure & Maintain

Task scheduling

  • cron: crontab -e; field order min hour day-of-month month day-of-week. 0 2 * * 1-5 = 02:00 weekdays; */5 * * * * = every 5 min. System-wide files in /etc/cron.d/ add a username field.
  • at for one-shots: at 23:00 → type commands → Ctrl+D; list atq, remove atrm.
  • V10 systemd timers: a .timer unit with OnCalendar= paired with a .service; activate with systemctl enable --now name.timer; list with systemctl list-timers.

Time services

  • chrony: dnf install -y chrony && systemctl enable --now chronyd; point at a server in /etc/chrony.conf: server classroom.example.com iburst (include iburst), restart chronyd, verify with chronyc sources -v (^* = synced).
  • timedatectl set-timezone America/Chicago · timedatectl set-ntp true.

Software — dnf, repos (and V10: Flatpak)

  • dnf install/remove/search/info, groups via dnf group install, history via dnf history. The lifesaver: dnf provides */semanage — find which package ships a missing command.
  • Local repo from exam-provided URLs (memorize the .repo format cold — you get the baseurl, not the syntax):
    /etc/yum.repos.d/local.repo → [baseos] / name=BaseOS / baseurl=http://…/BaseOS (or file:///mnt/BaseOS) / enabled=1 / gpgcheck=0. RHEL media has TWO repos — define both BaseOS and AppStream.
  • Kernel updates: dnf update kernel installs alongside the old one; GRUB keeps both (safe rollback).
  • V10 Flatpak: flatpak remote-add --if-not-exists flathub <url> · flatpak install/uninstall/list · flatpak remotes.
  • V10 Bootloader: edit /etc/default/grub then regenerate with grub2-mkconfig -o /boot/grub2/grub.cfg; kernel args per-entry via grubby --update-kernel=ALL --args="…".

8 · Networking

nmcli — do it in one line

  • Static connection:
    nmcli con add con-name lab type ethernet ifname enp1s0 ipv4.method manual ipv4.addresses 192.168.1.10/24 ipv4.gateway 192.168.1.1 ipv4.dns 192.168.1.1
  • Modify: nmcli con mod lab +ipv4.dns 8.8.8.8 (the + appends). Then nmcli con up lab — modifications don't apply until you re-up the connection.
  • ipv4.method manual is mandatory for static addressing (otherwise DHCP overrides you). IPv6 mirrors it: ipv6.method manual ipv6.addresses ….
  • Inspect: nmcli con show, nmcli dev status, ip a, ip route.

Hostname & resolution

  • hostnamectl set-hostname server1.example.com; add static entries to /etc/hosts; DNS servers live in the connection profile (nmcli), not hand-edited resolv.conf.
A network mistake is an exam-ender If your changes break connectivity or don't persist, the grader can't reach the system — one 2025 taker scored 0% on networking after using nmtui without verifying persistence. Use nmcli, re-up the connection, then reboot and confirm the address, gateway, DNS, and hostname all stuck.

9 · Users & Groups

  • useradd -u 2000 -G wheel,devs -s /bin/bash -c "Bob" bob · service account: useradd -s /sbin/nologin svc · userdel -r removes the home dir too.
  • usermod -aG devs bob — the -a matters: -G alone replaces the supplementary group list. Groups: groupadd -g 5000 devs, groupmod, groupdel; check with id bob.
  • Password aging (chage): chage -M 90 -m 7 -W 5 bob (max/min/warn) · force change at next login chage -d 0 bob · account expiry chage -E 2026-12-31 bob · view chage -l bob. Defaults for new users: /etc/login.defs.
  • Privileged access: drop a file in /etc/sudoers.d/ (e.g. bob ALL=(ALL) ALL), validate with visudo -cf — or simply usermod -aG wheel bob (wheel is pre-enabled in sudoers).

10 · Security — firewalld, umask, SSH keys, SELinux

firewalld

  • firewall-cmd --permanent --add-service=http · --permanent --add-port=8080/tcp · then firewall-cmd --reload.
  • Inspect: --list-all, --get-services. Made runtime-only changes you want kept? --runtime-to-permanent.
The firewalld double-trap --permanent alone changes nothing now (needs --reload); a rule without --permanent works now but dies at reboot. Do both, every time.

umask & SSH keys

  • umask subtracts from 666 (files) / 777 (dirs): umask 027 → files 640, dirs 750. Set persistently in /etc/profile.d/ or the user's ~/.bashrc.
  • Key auth: ssh-keygen → ssh-copy-id user@host → verify passwordless login. Keys live in ~/.ssh/authorized_keys (dir 700, file 600).

SELinux — where most exam points hide

  • Modes: getenforce; setenforce 0|1 (runtime); persistent in /etc/selinux/config (enforcing/permissive/disabled).
  • Contexts: view with ls -Z / ps -Z. The persistent-context recipe:
    semanage fcontext -a -t httpd_sys_content_t '/web(/.*)?' → restorecon -Rv /web. Always single-quote the regex. Find the right type by copying a working example: semanage fcontext -l | grep /var/www.
  • Never use chcon for exam tasks — it's not stored in policy and is lost on relabel; graders' relabels wipe it.
  • Non-standard ports: semanage port -a -t http_port_t -p tcp 82 (list: semanage port -l | grep http).
  • Booleans: getsebool -a | grep httpd; set with setsebool -P — without -P it's gone at reboot.
  • Diagnose denials: ausearch -m AVC -ts recent, sealert -a /var/log/audit/audit.log.
  • semanage missing? It ships in policycoreutils-python-utils — find it yourself with dnf provides */semanage.

11 · Containers with Podman EX200V9 only — removed in V10

  • Images: podman pull registry.access.redhat.com/ubi9/ubi · podman images · podman inspect · inspect without pulling: skopeo inspect docker://registry… · private registries: podman login.
  • Build from a Containerfile: podman build -t myimg .
  • Run: podman run -d --name web -p 8080:8080 -v /home/user/www:/var/www:Z IMAGE — the :Z relabels the volume for SELinux (forget it → permission denied). Manage: podman ps -a, stop, start, rm, logs.
  • Rootless can't bind ports below 1024 — map high ports (8080), not 80.
  • Container as a systemd service (the big V9 task):
    1. loginctl enable-linger $USER — without linger the service dies at logout.
    2. mkdir -p ~/.config/systemd/user && cd ~/.config/systemd/user
    3. podman generate systemd --new --files --name web
    4. systemctl --user daemon-reload && systemctl --user enable --now container-web.service
    systemctl --user needs a real SSH login session as that user (not su -).

12 · Study Materials (community consensus)

Synthesized from 30+ threads across r/redhat, r/linuxadmin, r/sysadmin and the Red Hat Learning Community (2023–2026 pass write-ups). The consensus is unusually strong.

TL;DR: Sander van Vugt (book + videos + practice exams) is "the gold standard" — cited in ~20 of 30 threads, often as the only resource needed. Access it via O'Reilly (~$49/mo, free trial, or free via many public libraries) instead of paying full course price. Add Ghori's book for depth, a 2-VM home lab on free real RHEL, and drill van Vugt + Lisenet (free) practice exams until they're easy under time.

1 · Books & courses

ResourceCommunity view
#1Sander van Vugt — RHCSA Cert Guide (RHEL 9 & RHEL 10 editions) + O'Reilly video course + live crash-course sessions"The Bible of the EX200 exam." The practice labs/exams are the killer feature — "if you can do all 4 labs in the back of the book you will pass." Updates fastest for new RHEL versions. Cons: known errata ("verify everything"), dry delivery.
#2Asghar Ghori — RHCSA Training and Exam Preparation Guide (RHEL 9 3rd ed. / RHEL 10 4th ed.)Near-equal favorite, usually alongside van Vugt: "exercises tougher than the test." ~$40 ebook with four practice exams. Cons: typos, weaker container coverage. The most common winning stack = Ghori for depth + van Vugt for videos/practice.
Red Hat official — RH124/RH134 (or RH199 Rapid Track), Red Hat Learning SubscriptionExcellent labs, but list price ~$5–7.5k — only if your employer pays. RHLS becomes genuinely worth it past RHCSA/RHCE where third-party material thins out.
FreeYouTubeIncreasingly used as primary material: Beanologi's RHCSA 9 series (a 286/300 passer spent $15 total), Red Hat's "Into the Terminal."
Udemy / othersNo consistent winner. Imran Afzal = fine beginner on-ramp but flagged as dated for exam prep; KodeKloud lectures OK but its mock-exam grading is buggy.

2 · Practice exams & labs most important

  • #1Van Vugt's practice exams (book appendix + O'Reilly) — the de facto readiness gate: "keep doing them until you can complete them in your sleep."
  • FreeLisenet.com practice exam — the best free mock, styled differently from van Vugt's (a good complement). Readiness bar: complete it cold, under time, offline.
  • Ghori's four included exams; Beanologi's exam-style videos.
  • GitHub lab environments: aggressiveHiker/rhcsa9 (current recommendation); the older rdbreak/rhcsa8env Vagrant lab is now dated. CertDepot per-objective pages remain a useful reference (much RHEL 7/8-era content though).

3 · Home lab (non-negotiable for this exam)

  • Free real RHEL: the Red Hat Developer Subscription for Individuals (developers.redhat.com) gives a free account with licenses for up to 16 systems. Rocky/Alma work in a pinch, but since real RHEL is free — use RHEL.
  • Topology: two small VMs (server + node, mirroring the exam), ~2 GB RAM / 20 GB disk each, plus spare virtual disks for storage tasks. Any hypervisor (KVM/virt-manager, VirtualBox, Proxmox).
  • Practice offline, in exam conditions — no internet, man pages only.

4 · Typical timelines

  • Daily Linux user / working sysadmin: ~1–2 months (some pass on "3 weeks at 10 hrs/week").
  • Little or no Linux background: ~3–6 months. Universal caveat: hands-on hours matter more than calendar weeks.
Dumps are pointless here — and risky There's no answer key to memorize on a live, script-graded machine. Circulating "dump" task lists are stale RHEL 8 content that actively misleads, and pirated official courseware carries NDA-violation / cert-revocation risk. Spend the time in the lab instead.

Sources

13 · Study Plan (Retention-Based, ≈6–10 weeks)

The RHCSA is the purest possible case for learning by doing: the exam is the practice. Reading about LVM earns zero points; typing the commands until they're muscle memory earns all of them. Every principle below is applied through the lab.

PrincipleHow to apply it to RHCSA
Generation effectNever copy-paste from the book — type every command. Break things on purpose and repair them.
Active recallRe-do each task from a blank terminal with no notes — man pages only (exam conditions). If you had to peek, it goes back on the re-drill list.
Spaced repetitionRotate old objective areas into each session (10-min warm-up: yesterday's tasks). Root-password reset, fstab, SELinux contexts, nmcli — re-drill weekly regardless.
InterleavingMock exams mix storage + users + SELinux + networking in one sitting — practice mixed task sets, not single-topic marathons.
Testing effectFull timed mocks early and often, not just at the end. Each mock's misses define next week's drills.
PhaseFocusActions
Week 1Lab + essential toolsBuild the 2-VM RHEL lab (free Developer Subscription) with spare disks. Drill §2–§3: redirection, grep, find, tar, links, permissions, a few small scripts.
Weeks 2–3Systems & storage§4–§6: boot targets, root-password reset until it's reflex, journald, services; partitions → LVM → fstab → NFS/autofs. Reboot after every task; mount -a before every reboot.
Weeks 4–5Config & security§7–§10: cron/at(+timers on V10), chrony, repos (.repo syntax cold), nmcli one-liners, users/chage/sudoers, firewalld, the SELinux recipe (semanage fcontext + restorecon). V9: containers §11. V10: Flatpak + bootloader.
Week 6+Mock examsVan Vugt's labs + Lisenet, full 3-hour offline blocks. Grade yourself by rebooting and re-checking every task. Re-drill misses at spaced intervals; repeat mocks until comfortable with ~30 min to spare, then book.

Experienced admins compress to ~3–4 weeks; true beginners should extend weeks 1–5 and consider RH124/RH134 material first.

Readiness bar You're ready when you can complete a full mock cold — offline, no notes, inside 3 hours — and every task still works after a reboot. That reboot check is the whole exam in miniature.

14 · Exam-Day Tips & Common Traps

Strategy

  • Skim all tasks first (10–15 min), knock out easy wins, skip-and-return on hard ones — but use your full 3 hours; skipped tasks may be heavily weighted.
  • Reserve the last 15–30 minutes for a reboot + verification pass over every task. "Reboot often: as soon as you did something that can be affected by a reboot, consider rebooting."
  • Set up SSH keys between the exam systems early — saves minutes on every subsequent task.
  • Esc can be broken in the exam's browser console — Ctrl+[ is Esc in vim.
  • Asking the proctor about task content can cost points; ask only about environment problems.

The trap list (each one has zeroed real candidates' categories)

  • fstab typo → emergency mode at grading. mount -a after every fstab edit, then findmnt --verify.
  • systemctl start without enable (or vice versa) → use enable --now.
  • firewall-cmd without --permanent (dies at reboot) or --permanent without --reload (never applies).
  • chcon instead of semanage fcontext + restorecon — lost on relabel. And setsebool without -P.
  • Forgetting touch /.autorelabel in the root-password reset.
  • usermod -G without -a — wipes the user's existing groups.
  • nmcli changes not re-upped / not persistent — a dead network can zero the whole category (the grader can't reach the box).
  • autofs: pre-creating indirect mount dirs / botching the * and & wildcard syntax.
  • V9 containers: missing :Z on volumes, missing loginctl enable-linger, testing systemctl --user from su - instead of a real login.
  • Defining only one of the two repos (BaseOS and AppStream).
The mantra Does it work? Will it still work after a reboot? Prove it. If you internalize one habit from this guide, make it that one.

↑ back to top