# Your first cybersecurity lab: a practical starting plan

> Choose a starting route, work through a small Linux example, and turn one practice session into notes you can use again.

Canonical: https://codelivly.com/blog/choose-your-first-cybersecurity-path

| | |
|---|---|
| Category | Getting started |
| Author | Codelivly team |
| Reading time | 7 min |

You open a cybersecurity course and immediately meet five unfamiliar tools. You copy a command, get a different result, and spend the rest of the session installing something you do not yet understand. The problem may be the starting point: the exercise assumes knowledge you have not practised.

A useful first session has a smaller target. Find a file. Explain a network connection. Read one HTTP exchange. Finish with enough evidence to explain what happened without replaying a video. This article helps you choose that target, work through a short example, and decide what to study next.

 **What you need**

A browser, a notebook, and access to the room you choose. The command transcript below is an illustrative Linux example, not a recording of a particular Codelivly task. Browser simulations support the commands defined by their exercise; follow the room instructions when they differ.

## Choose a route by the question you want to answer

You do not need to choose a job title before learning the basics. Pick a question that interests you and check whether you can explain its prerequisites. If you cannot describe a file path yet, a complex investigation will involve two problems at once: understanding the evidence and learning how to reach it.

| Your question | First practice | Evidence to keep |
|---|---|---|
| Where is this file, and what does it contain? | [Introduction to Linux](https://codelivly.com/rooms/introduction-to-linux) | A command, its output, and the path you inspected. |
| How does this device reach another service? | [Networking Fundamentals](https://codelivly.com/learning-paths/networking-fundamentals) | A small diagram showing endpoints, direction and protocol. |
| What does this login alert actually establish? | [SOC Fundamentals](https://codelivly.com/learning-paths/soc-fundamentals) | A timeline that separates observation from interpretation. |
| What happens when I open a web page? | [Web Fundamentals](https://codelivly.com/learning-paths/web-fundamentals) | An annotated request and response with secrets removed. |

Commit to one route for a few sessions, then review the evidence you produced. Switching is reasonable when you discover a missing prerequisite. Switching every time an exercise becomes unfamiliar makes it harder to tell whether you are improving.

## A small Linux exercise, explained line by line

Imagine an exercise asks you to read `brief.txt` inside a `case` directory. The following transcript describes a sample filesystem created for this article. You do not need to create these files on your computer to understand it.

```bash
$ pwd
/home/learner
$ ls
case  notes.txt
$ ls case
brief.txt  events.log
$ cat case/brief.txt
Find the first unsuccessful login in events.log.
```

`pwd` reports the working directory. That gives meaning to the relative path `case/brief.txt`: start in the working directory, enter `case`, then identify `brief.txt`. An absolute path to the same file in this example is `/home/learner/case/brief.txt`. The distinction matters because a relative path can point somewhere else after you change directories.

`ls` shows entries, but an ordinary listing does not establish their contents or ownership. `ls case` inspects the named directory without changing your working directory. `cat case/brief.txt` prints the file's contents. It does not search the event log or prove that a login occurred; it only reveals the exercise instruction.

That is already a useful sequence: establish context, inspect the available material, then read the instruction. The next command should follow the question and the supported tools in the room. A command list copied from elsewhere is not a substitute for that decision.

### When the result does not match

If the shell reports `No such file or directory`, compare the exact spelling and letter case with the listing, then check the working directory. Do not immediately assume the exercise is broken. If the room uses a limited simulator, consult its help or instructions before trying flags from a full Linux installation.

If a command returns no output, record that fact. An empty search result could mean no match, the wrong file, a narrower search than intended, or a command the simulation does not implement. These explanations lead to different next checks. Preserve the command and any error message so you can distinguish them.

## Keep a notebook that helps you resume

A screenshot of a green completion badge records progress. It rarely explains your reasoning. A useful note records enough context that you can return tomorrow and understand why you ran a command.

| Field | Example entry |
|---|---|
| Question | Where are the case instructions? |
| Context | Sample filesystem; working directory /home/learner. |
| Action | Listed case, then read case/brief.txt. |
| Observation | The brief asks for the first unsuccessful login in events.log. |
| Interpretation | The next step is to inspect the event log. No login has been verified yet. |
| Next check | Read the log format and timestamps before choosing a filter. |

Write the observation before the interpretation. This habit is useful far beyond Linux: a response code, an alert label and a cloud policy each tell you something specific, with limits. Learning to state those limits prevents confident but unsupported conclusions.

## Use a session with a clear stopping point

The following is a suggested practice routine, not a promise that every room takes this long. Adjust it to the exercise and your available time.

1. **Set one question.** Read the room introduction and identify what you need to find. Note any setup or scope restriction before opening tools.
2. **Inspect before acting.** Identify the environment and available evidence. Keep the first useful observation, even if it contradicts your expectation.
3. **Work through one task.** If you use a hint, record the missing concept it supplied. A hint is more useful when you revisit why you needed it.
4. **Explain the result.** Write two or three sentences connecting evidence to your answer. Include anything you could not verify.
5. **Choose the next session.** Continue the room, repeat an unfamiliar step, or study the prerequisite that blocked you.

If a task takes longer than planned, stop at a documented boundary: the last command that worked and the exact question still open. That is easier to resume than an unexplained folder full of screenshots.

## How to tell whether you should move on

Try the exercise again without the walkthrough. You do not have to remember every command flag. You should be able to describe the goal, locate the relevant evidence and explain why the result answers the question. Looking up syntax is compatible with understanding; copying a sequence without knowing what it inspects is a signal to slow down.

For the Linux example, ask yourself: what changes if the working directory is `/home/learner/case`? Why would `cat case/brief.txt` then look in the wrong place? What would you check before deciding that a file is missing? Explain the answer in your own words.

 **Try this next**

Open one beginner room and complete a single task. Keep the question, command, observation and interpretation. Close your notes, explain the task aloud, then reopen them and correct anything you could not justify. The [first-lab checklist](https://codelivly.com/downloads/codelivly-first-lab-checklist.txt) gives you a reusable starting page.

## Build a route from the work you enjoyed

If you enjoyed navigating files, continue with Linux and basic networking. If you enjoyed reconstructing a sequence of events, explore [SOC Analyst Level 1](https://codelivly.com/career-paths/soc-analyst-level-1) after the fundamentals. If the request/response model interests you, work through Web Fundamentals before the intermediate [Web Application Security](https://codelivly.com/learning-paths/web-application-security) path.

Keep a small collection of your best explanations. Respect each room's answer-sharing rules; do not publish flags, secrets or another learner's data. A portfolio entry can explain the skill and method without disclosing the challenge solution. Certificates record the platform's defined completion and assessment requirements; they are not a guarantee of employment.

For command details beyond a simulator, consult the [GNU Coreutils working-context documentation](https://www.gnu.org/software/coreutils/manual/html_node/Working-context.html). Use the room's supported commands during the exercise rather than assuming every option in a system manual is available.
