CompTIA Linux+ (XK0-006) Study Guide: Format, Domains, Cost, and How to Pass

CompTIA Linux+ (XK0-006) is the vendor-neutral certification that proves you can administer real Linux servers — Red Hat-family and Debian-family alike — from the boot process through storage, services, security, scripting, and troubleshooting. The exam presents a maximum of 90 questions (multiple-choice plus interactive performance-based questions) in 90 minutes, and you need a scaled score of 720 out of 900 to pass. A voucher costs $399, and you take the exam through Pearson VUE either at a test center or online via OnVUE. XK0-006 launched on July 15, 2025 and is the current version of Linux+, adding Python fundamentals, infrastructure-as-code depth, and — for the first time on any CompTIA infrastructure exam — AI best practices for system administrators.

This guide covers the certification itself, the exact exam format, all five domains with what each actually tests, cost and registration, a six-week study plan, and the exam-day habits that separate a 720 from a 690.

What Linux+ is (and who it’s for)

Linux+ certifies working competence as a Linux system administrator. Unlike distribution-specific credentials (Red Hat’s RHCSA, for example), it is deliberately cross-distribution: questions expect you to know both dnf/rpm and apt/dpkg, both SELinux and AppArmor, both firewalld and ufw. That breadth is the point — most real environments are mixed, and hiring managers use Linux+ as evidence you can sit down at any distribution and be productive.

The typical candidate is a junior sysadmin, support engineer, or DevOps-track professional with around a year of hands-on Linux experience. CompTIA recommends roughly 12 months of experience plus Network+-level networking knowledge, but there are no formal prerequisites — nothing stops a motivated beginner with a home lab from registering tomorrow. Roles that map directly to the credential include Linux administrator, cloud engineer, site reliability engineer (entry level), DevOps engineer, and technical support engineer at any company running Linux servers — which, in practice, is nearly all of them.

XK0-006 replaced XK0-005 as the current objective set. If you own study material, check the exam code on the cover: the versions differ meaningfully. XK0-006 assumes a systemd world (unit files, targets, timers, journald), treats containers and infrastructure-as-code as core skills rather than extras, adds basic Python alongside Bash, and introduces an entire objective on responsible AI use in system administration. Material written for XK0-005 will leave holes exactly where the new exam concentrates its hardest questions.

How does Linux+ compare to the alternatives? RHCSA (Red Hat Certified System Administrator) is a hands-on, terminal-only exam that carries more weight in Red Hat shops but tests nothing about Debian-family tooling. LFCS (Linux Foundation Certified System Administrator) is also performance-based and distribution-flexible but has far less name recognition with HR filters. Linux+ occupies the middle ground: broader than RHCSA, better known than LFCS, and the only one of the three that also examines the surrounding professional context — Git workflow, infrastructure-as-code concepts, and AI usage policy. If your goal is a first Linux credential that recruiters recognize across environments, Linux+ is the default choice; if you are headed into a Red Hat-only enterprise, consider RHCSA as the follow-up rather than the replacement.

Like other CompTIA certifications, Linux+ is valid for three years and renewable through the Continuing Education (CE) program — earning CEUs, retaking the current exam, or passing a higher-level qualifying certification all renew it.

The XK0-006 exam at a glance

Detail	XK0-006
Launched	July 15, 2025
Questions	Maximum of 90
Question types	Multiple-choice (single and multiple response) and performance-based questions (PBQs)
Time limit	90 minutes
Passing score	720 on a scale of 100–900
Voucher price	$399 (raised from $369 in the May 2026 CompTIA price change)
Delivery	Pearson VUE — in-person test center or OnVUE online proctoring
Prerequisites	None (about 12 months of Linux administration experience recommended)
Validity	3 years, renewable via CompTIA CE

The math on that table matters: up to 90 questions in 90 minutes is one minute per question, and PBQs — interactive simulations where you might assemble a command pipeline, order boot-sequence steps, or match services to ports — routinely consume three to five minutes each. Budgeting time around the PBQs is a skill you should practice before test day, not discover during it.

How scoring works

The 720 passing mark is a scaled score, not a percentage. CompTIA converts your raw performance onto a 100–900 scale that accounts for question difficulty across exam forms, so “720 out of 900” does not mean “80% correct” — the raw percentage needed varies by form and is never published. Two practical consequences follow. First, chasing an exact percentage on practice exams is a rough proxy at best; consistently scoring in the mid-80s on honest practice material is the signal most successful candidates report. Second, because harder questions and easier questions both feed the scale, an unanswered question hurts more than a wrongly answered one — which is why finishing every item, even with guesses, is non-negotiable strategy. “Maximum of 90 questions” is also literal: forms vary, and some candidates see fewer. A counter that stops at 84 does not mean your exam glitched. Your pass/fail result appears on screen at a test center within moments of submitting; a score report with domain-level breakdown follows in your certification account either way, and the breakdown is your study map if a retake is needed.

Domain 1: System Management (23%)

The heaviest domain covers the daily mechanics of running a Linux box: the boot chain, storage, filesystems, package management, file manipulation, and working at the shell.

Boot topics span firmware (BIOS/UEFI) through bootloader (GRUB2) to the kernel and the initial RAM filesystem. Expect questions on what initramfs actually does and where it sits in the boot chain, including embedded-board variations like U-Boot. Storage questions go deep: partitioning GPT disks with gdisk, cgdisk, and sgdisk, building LVM stacks (physical volume → volume group → logical volume), creating filesystems, and wiring persistent mounts through /etc/fstab — including CIFS network shares and credentials files. A classic exam trap: what happens at boot when an fstab entry points at a device that no longer exists.

Package management covers both families. On the Debian side, know the apt/dpkg relationship well enough to handle failure states — what apt --fix-broken install repairs and when you need it. On the Red Hat side, know dnf, rpm, and repository configuration.

File and text manipulation questions expect fluency with find, grep, sed, awk, redirection, and links — plus the locating tools: locate and its updatedb index, versus which and type for finding binaries in your PATH. Editors still appear on the modern exam: vim’s modes, search-and-replace, and the various ways to save or bail out remain testable, because vi is the one editor guaranteed to exist on any rescue image. Archiving rounds out the domain — tar versus cpio versus zip, including which tool pairs with find and which compresses versus merely bundles.

Domain 2: Services and User Management (20%)

This domain is systemd’s home turf. You need to read and write unit files — service types, Restart= policies, and the difference between reload, restart, and daemon-reload; understand targets and how they map to the old SysV runlevels, including rescue and emergency modes; and schedule recurring work with systemd timers versus classic cron, knowing what timers add (logging via the journal, Persistent= catch-up runs, dependency handling) and when a plain crontab is still the simpler answer.

The user-management half covers account lifecycle (useradd, usermod, passwd, chage), group administration, /etc/passwd and /etc/shadow internals, sudo and sudoers syntax, and profile/skeleton files. Expect scenario questions that mix the two halves — for example, a service account that needs a nologin shell and a systemd service running under it.

Domain 3: Security (18%)

Security on XK0-006 is hands-on hardening, not theory. Core areas: file permissions and special bits (SUID, SGID, sticky), access control lists, mandatory access control (SELinux contexts and booleans, AppArmor profiles), firewalls (firewalld zones, ufw, nftables), SSH hardening, and certificates.

Authentication policy runs through PAM (Pluggable Authentication Modules): know how pam_pwquality and pwquality.conf enforce password length, complexity, and history requirements, because the exam loves asking which file you edit to make a specific policy change. Auditing and logging center on journald — journalctl filtering by unit, priority, and boot; making the journal persistent; and understanding its rate-limiting — alongside classic syslog and auditd. Data-destruction questions round the domain out: when decommissioning a disk, know the secure-erase options — wipe, shred, dd, and blkdiscard — and why a plain rm never qualifies.

Domain 4: Automation, Orchestration, and Scripting (17%)

The automation domain expects real scripting literacy: Bash constructs (loops, conditionals, exit codes, variables, quoting) plus — new in XK0-006 — Python basics for administrative tasks (reading files, simple data structures, pip awareness). Version control with Git is testable at the working level: clone, branch, commit, merge, pull request flow.

Infrastructure-as-code and orchestration questions cover Ansible concepts (playbooks, inventories, idempotency), container basics with Docker and Podman (images versus containers, volumes, registries), and CI/CD concepts at the definition level.

The genuinely new territory is AI. XK0-006 is the first Linux+ version with an objective dedicated to responsible AI use in system administration — data governance, prompt engineering, human review of AI-generated code, and accountability. These questions are scenario-driven judgment calls: what you may paste into a hosted AI tool, who is accountable when an AI-suggested script breaks production, and what policy gates belong in front of an AI-authored pull request. Candidates who skip this material because it “isn’t real Linux” give away easy points.

Domain 5: Troubleshooting (22%)

The second-heaviest domain, and the one that most rewards actual experience. Questions follow a consistent shape: symptoms plus command output, then “what is the cause?” or “what do you run next?” Coverage spans boot failures, service startup problems, network connectivity (DNS resolution order, routing, ip, ss, nmcli), performance analysis (CPU, memory, swap, top, vmstat), and storage.

Storage troubleshooting is a favorite: interpreting S.M.A.R.T. data with smartctl to judge whether a disk is failing, plus iotop and dmesg for diagnosing I/O bottlenecks and bus errors, full filesystems versus exhausted inodes, and read-only remounts after errors. Practice reading real command output — the exam reproduces it faithfully, down to the columns.

A useful habit for this domain: internalize a methodology, not just commands. The exam rewards the candidate who checks the cheapest, most likely cause first — is the service running, is the port listening (ss -tlnp), does the name resolve (dig, /etc/nsswitch.conf order), is the disk full (df -h, df -i) — before reaching for exotic tools. Many “what do you do NEXT” questions are really asking whether you follow an ordered diagnostic path or jump straight to a reboot. When two answers would both eventually work, the one that gathers information without changing state usually scores.

Registration and cost

Registration runs through CompTIA and Pearson VUE:

1. Create a CompTIA account and buy an XK0-006 voucher ($399 since the May 2026 price change) from the CompTIA store, or buy a bundle that includes training or a retake.
2. Schedule through Pearson VUE: pick an in-person test center or OnVUE online proctoring.
3. For OnVUE, run the system test on the machine you will use, and prepare a room that is private, quiet, and clear of papers and second monitors. The proctor checks the room by webcam, and leaving camera view during the exam can void your attempt.
4. Bring one valid government-issued photo ID (test center) or have it ready for webcam check-in (OnVUE).

Vouchers expire — typically 12 months from purchase — so don’t buy one until your study plan has a realistic exam date. If your employer has a CompTIA academic or partner arrangement, discounted vouchers are common; ask before paying retail.

A six-week study plan

This plan assumes roughly an hour on weekdays and two to three hours on weekends, with a running Linux VM (one Red Hat-family, one Debian-family — both free) as your lab.

Week 1 — System Management, part 1. Boot chain end to end: firmware, GRUB2, initramfs, kernel, systemd. Partition a practice disk with gdisk, build an LVM stack, make filesystems, mount them through fstab, deliberately break an fstab entry, and recover. Do everything twice — reading about storage does not stick; typing it does.

Week 2 — System Management, part 2. Package management on both families, including breaking and repairing dependencies. File tools: find, grep, sed, tar, cpio, links, permissions. Live in vim all week — force yourself through mode switching, search-and-replace, and the write/quit variants until they’re reflex.

Week 3 — Services and User Management. Write a unit file from scratch for a script of your own, experiment with Restart= policies, convert a cron job to a timer pair. Switch targets, boot to rescue mode on purpose. Build users and groups, configure sudoers, expire a password with chage.

Week 4 — Security. Set a password policy in pwquality.conf and watch PAM enforce it. Toggle SELinux booleans, write firewalld rules, harden sshd_config. Make the journal persistent and practice journalctl filters until you can pull “errors from the previous boot for one unit” without looking anything up.

Week 5 — Automation and AI. Write Bash scripts with loops and exit-code handling; write a short Python script that parses a log. Run through Git branch-commit-merge. Read Ansible playbook examples until idempotency clicks. Study the AI best-practices objective properly — it is judgment-based and fast to learn, which makes it the best points-per-study-hour on the exam.

Week 6 — Troubleshooting and full practice. Timed, full-length practice exams. Score every wrong answer against its domain and drill the weakest one. Practice PBQ-style tasks under time pressure. Two days out, stop learning new material and consolidate; the night before, sleep.

Throughout all six weeks, use practice questions as diagnosis, not just rehearsal — a wrong answer tells you exactly which man page to open next.

Exam-day tips

• Flag long PBQs and return to them. PBQs load first and eat clock. If one looks like a five-minute build, flag it, clear the multiple-choice (where most of your points live), and come back.
• One minute per question is the budget. Anything you can’t answer in 90 seconds gets a flag, a best guess, and your attention later.
• Answer everything. There is no penalty for wrong answers; a blank is the only guaranteed zero.
• Read for the qualifier. XK0-006 stems turn on words like persistent, at boot, without restarting the service, FIRST, and BEST. Two answers are often both “correct” — the qualifier decides which one scores.
• Trust command muscle memory over doubt. If you’ve typed journalctl -u nginx -b -1 a dozen times in your lab, don’t second-guess the flag order because the exam room feels different.
• Know your distribution context. When a question says dnf or mentions SELinux, you are in Red Hat land; apt or AppArmor puts you in Debian land. Answers that mix families are usually distractors.

Quick reference

• XK0-006 launched July 15, 2025; it is the current Linux+ exam version, replacing XK0-005.
• Maximum 90 questions (multiple-choice plus PBQs) in 90 minutes; pass at 720 on a 100–900 scale.
• Voucher: $399, raised from $369 in the May 2026 CompTIA price change; delivered via Pearson VUE test center or OnVUE.
• Five domains: System Management 23%, Troubleshooting 22%, Services and User Management 20%, Security 18%, Automation/Orchestration/Scripting 17%.
• Cross-distribution by design: know dnf/rpm and apt/dpkg, SELinux and AppArmor, firewalld and ufw.
• New in this version: Python basics, deeper IaC/containers, and an AI best-practices objective — free points if you study them, holes if you don’t.
• No prerequisites; about 12 months of hands-on experience recommended; certification valid 3 years via CompTIA CE.
• PBQ time management is the most common self-inflicted failure — practice full-length timed exams before test day.