LPI 702-100: BSD Administration Across FreeBSD, NetBSD, and OpenBSD

LPI 702-100 is the current version 1.0 exam for the BSD Specialist certification. The credential focuses on practical administration across FreeBSD, NetBSD, and OpenBSD rather than treating one project as the only “real” BSD. LPI does not require another certification before taking the exam; the challenge comes from understanding common Unix ideas while remembering where commands, files, package systems, boot behavior, and administration practices diverge among the three operating systems.

That cross-BSD perspective is the organizing principle for preparation. A command name can exist on multiple systems but behave differently, and a service-management or package workflow that is normal on one family member may be wrong on another. The broader LPI certifications inventory provides vendor context, while the dedicated BSD Specialist destination is the certification-level path for candidates targeting 702-100.

A good lab uses three small virtual machines—one per BSD—so every major task can be compared immediately. Install them, record the boot process, manage software, create users, inspect hardware, configure storage and networking, and keep a three-column notebook of differences. The exam becomes much easier when “common Unix concept” and “project-specific implementation” are deliberately separated.

Installation and upgrades reveal the philosophy of each BSD project

702-100 expects candidates to install and upgrade FreeBSD, NetBSD, and OpenBSD, identify the running system and version, and understand the basic administrative tools used by each project. The installation experience differs, but the operational questions remain consistent: where the system came from, how updates are applied, and how an administrator verifies the resulting release. Keep the commands project-specific in your notes so familiarity with one installer does not create false confidence on another BSD.

Install all three systems with conservative defaults, record the partitioning and network decisions, query the running version, and perform a small supported update or package refresh on each. If BSD behavior differs, inspect service, package, filesystem, and network dependencies before reconfiguring.

Boot and service management require both shared Unix knowledge and local syntax

Candidates should understand boot loaders, startup scripts, rc configuration, single-user mode, shutdown, and the service-control mechanisms used by each BSD. A service may be installed correctly but absent after reboot because the persistent startup configuration was never enabled. The useful comparison is not “which command is best,” but how each system expresses enabled state and where the administrator verifies it.

Enable the same simple network service on all three systems, reboot, verify it starts automatically, then disable it and confirm the persistent state rather than relying only on a running process.

Cross-BSD study works best when the administrative objective is kept constant while the implementation changes. Installing software, enabling a service, configuring an interface, mounting storage, or managing a user are familiar Unix tasks, but each project expresses parts of them differently. Build notes around the outcome first and then record the FreeBSD, NetBSD, and OpenBSD mechanisms beside one another. This prevents the comparison from turning into three disconnected command lists and makes differences meaningful: a change matters because it alters where configuration lives, how state becomes persistent, or which component owns the behavior.

Hardware and kernel inspection begin with evidence collected at boot

The objectives include discovering hardware, reading boot messages, understanding kernel modules, and using BSD-specific tools for PCI, ATA, SCSI, and module management. A device that is physically present but absent from the operating system could reflect detection, driver, module, or configuration issues rather than a generic “hardware problem.” On 702-100, even valid syntax can produce the wrong operational result when identity, networking, storage, permissions, or an upstream dependency conflicts with the intended design. Build the habit of identifying what the kernel actually detected before editing higher-level configuration.

Inspect dmesg and the project-specific hardware utilities on each VM or physical test host, list loaded modules, and load or unload a harmless module where the platform supports it.

Storage administration should be practiced with disposable disks

BSD administration includes partitioning, filesystems, swap, mounting, filesystem checks, quotas or related controls, and an understanding of how each project names devices and organizes storage. Commands and device conventions differ enough that translating Linux muscle memory directly can be risky. Document every destructive command before running it; precision around device names is a practical safety skill as well as an exam skill.

Attach a small second virtual disk to each BSD, partition and format it using the native workflow, mount it persistently, fill part of it with test data, and verify how the system reports capacity and device identity.

Boot, storage, and software management are especially useful for learning project boundaries. The base operating system and third-party packages are not always maintained through the same path, and device naming or startup configuration can differ enough that Linux habits become unreliable shortcuts. A safe lab uses disposable disks and recoverable virtual machines so that partitioning, mounting, service startup, and update behavior can be tested without hesitation. After each change, verify both the live state and the configuration that should recreate it after reboot; that distinction exposes many subtle administration mistakes.

Software management is split between the base system and installed packages

BSD systems distinguish their core operating-system components from third-party software more explicitly than many Linux distributions, and each project has its own package and ports or source conventions. Treating every file as though it came from one package manager can lead to poor upgrade and recovery decisions. The important outcome is knowing which update mechanism owns which part of the machine.

Install the same common utility on all three systems, query its owning package, inspect repository or package configuration, remove it, and then compare how base-system updates are handled separately. On each BSD, practice reversing a package, service, storage, or network change using the project’s native mechanism and confirm that the system returns to the same observable state after reboot.

Users, processes, scheduling, and permissions still demand Unix fundamentals

Account files, groups, process signals, job control, cron, resource limits, permissions, and ownership remain central even when the surrounding administration differs by BSD. The exam can test familiar concepts in an unfamiliar system context, so relying on one distribution-specific helper tool is risky. Where syntax diverges, note the difference; where the concept is shared, focus on the invariant administrative objective.

Create users and groups, schedule a task, adjust file ownership and mode bits, send process signals, and inspect resource usage using utilities available across the BSDs.

Networking and security should also be compared by purpose rather than by brand name. Configure an address, route, resolver, and simple service on each system, then inspect how the configuration is made persistent and which native tools reveal the active state. Add one narrowly scoped security rule and verify both allowed and denied traffic. The goal is not to prove that one BSD is “better” than another, but to understand how each project implements familiar controls and what evidence an administrator should trust when the documented configuration and observed behavior disagree.

Networking should be compared from interface configuration through services

702-100 includes client networking, routing, name resolution, and the system-specific configuration needed to make changes persistent. A temporary address or route can make a test succeed while leaving the next reboot broken, which is why runtime and persistent state must be distinguished. A simple identity and access decision model also helps when network daemons are reachable but users are denied by local policy or service configuration.

Configure an address and default route, verify DNS resolution and transport reachability, then reboot and confirm the intended state returns on each BSD.

BSD security differences deserve deliberate comparison rather than generalization

OpenBSD, FreeBSD, and NetBSD share many security concepts but emphasize different defaults, firewall tools, privilege-separation practices, and hardening mechanisms. Importing a firewall or hardening procedure from another operating system without checking native semantics can create accidental exposure or outages. The exam rewards knowing the family resemblance without erasing the project-specific details that administrators rely on.

Take one administration task and choose the native approach on each BSD, explaining why copying a command from another Unix would be unsafe or incomplete. Identify the default firewall technology and one hardening mechanism on each system, apply a narrowly scoped rule in a disposable lab, and confirm both allowed and denied traffic.

The final lab should force rapid context switching without losing the troubleshooting method. Start from three clean systems and perform the same administrative sequence on each: install a package, create an account, prepare storage, configure networking, enable a service, reboot, and verify. Keep one shared checklist of objectives but separate notes for the project-specific commands and files. When a fault is introduced, diagnose it from the administrative layer that owns the behavior rather than reaching for the command remembered from a different operating system. That is the practical cross-BSD skill the exam is meant to surface.

Final preparation should prove you can switch context without losing the objective

BSD Specialist readiness is not memorizing three unrelated operating systems. It is recognizing the same administrative problem—install, boot, update, store, authenticate, route, troubleshoot—and knowing how each BSD expresses the solution. That portability is what makes 702-100 distinct from a Linux-only administration exam. If your reasoning stays stable while the commands and files change, you have learned the cross-BSD administration skill the certification is intended to validate.

Perform one end-to-end build on each system: install, update, create an account, add storage, configure networking, enable a service, reboot, and verify. Then swap machines and repeat from your own notes rather than a tutorial.

Project documentation is part of the skill because the correct source of truth can differ across the BSDs. Rather than memorizing paths from a comparison chart, use each system’s native manual pages and configuration examples to confirm how a service is expected to be managed. Record the command that shows live state, the file or mechanism that makes the change persistent, and the recovery step if the change prevents a clean boot or service start. Repeating that method across all three systems builds independence from memorized Linux conventions and makes unfamiliar administration less error-prone.

ExamSnap's LPI 702-100 Practice Test Questions and Exam Dumps, study guide, and video training course are complicated in premium bundle. The Exam Updated are monitored by Industry Leading IT Trainers with over 15 years of experience, LPI 702-100 Exam Dumps and Practice Test Questions cover all the Exam Objectives to make sure you pass your exam easily.