Categories
Training & Community

AWS DevOps Engineer Professional Exam Prep With Pepe Silvia

In this post, I share my experience passing the AWS DevOps Engineer – Professional exam, including study strategy, mock exams, time management and exam-day tactics.

Introduction

Back in March 2022, I wrote about passing the AWS Certified Developer – Associate certification. More recently, in May 2026, I took the AWS Certified DevOps Engineer – Professionalmy first AWS Professional certification.

I don’t usually write about exam prep — the strategies are personal, the technology moves fast, and there’s no shortage of good advice already out there. But I don’t see much written about the gap between the Associate and Professional certifications, so I thought I’d share my experience in this post.

First, I’ll examine some of those differences in detail. Then I’ll outline my study approach. Finally, I’ll share some survival tactics I used during the exam. And along the way, you’ll find out why one of my Steamhaus colleagues compared one of my strategies to the Pepe Silvia scene from It’s Always Sunny in Philadelphia.

pepesilvia
“Can we talk about the DevOps Pro please, Mac? I’ve been dying to talk about the DevOps Pro with you all day, okay?”

Professional vs Associate

This section explores some of the key differences between the AWS Associate and Professional certifications.

Before diving in, a quick note. Both AWS and Tutorials Dojo (which I’ll discuss later) offer excellent practice resources. While AWS still hosts older sample question PDFs (many of which haven’t been updated since 2022), the best place for their official materials is now the free tier of the AWS Skill Builder platform.

Scenario Length

The most obvious difference between the AWS Associate and Professional questions is length.

Professional exam questions are often much longer, sometimes two to three times as long as the Associate ones. And not all provided information is relevant. A major part of these exams is your ability to filter out noise and identify which constraints matter.

As evidence, look at this zoomed-out screenshot of Question 7 from the AWS DevOps Engineer – Professional sample PDF. I mean, LOOK AT IT.

2026 06 10 DOPQ7

It’s the entire page long! And, as I’ll discuss later, there’s not much time to read questions like these either. As for why many Professional questions are longer…

Knowledge vs Judgment

Associate questions generally check your understanding of what a service does. Professional questions assume you already know the technical terms and instead test your judgment over what actions to take.

To explore this, the Solutions Architect track offers the nearest like-for-like comparison. Let’s contrast Question 4 from the Solutions Architect – Associate sample exam questions:

2026 06 11 SAAQ4

With Question 3 from the Solutions Architect – Professional sample exam questions:

2026 06 11 SAPQ3

While the questions are thematically similar, they differ significantly in areas including:

Structure: The Associate question has a single correct answer. The Professional question requires two answers, each addressing a different layer of the architecture. This requires an understanding of how the services interact.

Scope: The Associate question focuses on a single service to solve a straightforward problem. The Professional question looks at the entire request pipeline: S3 serving the frontend, API Gateway handling the POST request and Lambda processing in the background. You must debug the whole system, not just choose the right service.

Detail: The Associate question provides only essential information. The Professional question includes additional elements that provide further context. It mentions that the team successfully tested each API method in the AWS console, which rules out server-side failures. Understanding this distinction is crucial for effective debugging.

Domain Structure

Associate exams focus on specific technical domains. Depending on the certification, these domains may include architectural best practices, development tasks or operational duties. Each domain is separate, making it easier to study and concentrate on one topic at a time.

Professional exams do not have clear boundaries. They require you to integrate knowledge from multiple domains at the same time, revealing something significant about what is actually being tested.

To see this in action, let’s look at the Solutions Architect track. The current version of the Solution Architect – Associate exam guide focuses on four domains:

  • Design Secure Architectures
  • Design Resilient Architectures
  • Design High-Performing Architectures
  • Design Cost-Optimised Architectures

These domains focus on the technical qualities of a workload. They closely align with the AWS Well-Architected Framework, and test the ability to identify the right services, apply best practices and recognise common design mistakes.

Conversely, the Solutions Architect – Professional exam guide takes a very different approach:

  • Design Solutions for Organisational Complexity
  • Design for New Solutions
  • Continuous Improvement for Existing Solutions
  • Accelerate Workload Migration and Modernisation

These domains are action-oriented and contextual, each specifying an action to perform rather than a quality to evaluate. They are open-ended and organisationally aware, rarely having a single correct answer.

Revision Strategy

This section explores my ways of preparing for the AWS DevOps Engineer Professional certification, including courses, mock exams and mental models.

Career Experience & Courses

2026 marks my tenth year working in technology, with the most recent two as an AWS Consultant at Steamhaus. While my day-to-day role naturally exposes me to several aspects of the DevOps Professional blueprint, it doesn’t cover all of them. That is where targeted courses come in.

I’m a longtime fan of Stephane Maarek, and had already bought his AWS DevOps Engineer – Professional Udemy course in a previous sale. The course covers a lot, but I felt less confident after finishing it than after his Associate courses. His DevOps course combines new lectures with material from his Associate courses. As a result, I found that some modules reinforced concepts I had already learned from the Associate-level material instead of providing the deeper context I wanted.

To fill the gaps, I used one of my Community Builder benefits – a free QA subscription. Danny Jessee‘s DOP-C02 preparation course covered similar topics to Maarek’s but delivered several lectures with the greater technical depth that I was seeking. The hands-on labs were also a massive help in demystifying some of the services and features I don’t often use.

With those gaps filled, it was time to start testing.

Mock Exams

Mock exams are likely the most valuable part of my study process. Since earning my first cloud certification in 2019, I have relied on the Maarek course and the associated Tutorials Dojo exams for each AWS certification.

Tutorials Dojo (TD) offers practice exams, cheat sheets and labs for several cloud certifications, including AWS, Azure and GCP. Each TD question bank has several modes, which I usually tackle in this order:

Section-Based: This mode focuses on specific topics and domains, giving the correct answer and a detailed explanation immediately after each question. This is great at flagging things I’ve misremembered, misunderstood or simply never touched, letting me refine my knowledge without burning through the question bank.

Review: This mode is more open-ended, posing questions from multiple domains. It isn’t timed and gives answers and explanations as before. I use this mode to build the mental stamina needed to answer large blocks of questions in bulk.

Timed: This mode mimics the exam. Questions are given under timed conditions, with a full report only upon completion. While some questions in the bank will now be familiar, this approach teaches me the strategies and timings I need for the actual exam.

After each session, I review the answers and identify topics and domains that are unfamiliar or problematic. What I do next with this knowledge has changed over the years…

Connecting The Dots

There’s no single correct way to use the results of a mock exam. Personally, I like to look for patterns in the areas where I’m struggling and connect them to topics I already understand.

For example, I was getting some ELB routing questions wrong, so I used my existing Route53 routing knowledge to fill in some gaps. I also had issues with some Elastic Beanstalk questions because I’m not a big user of the service, so I stepped away from the practice exams entirely to do a deep dive into the documentation and FAQs.

My goal isn’t to memorise answers. It’s to understand why an answer is correct well enough to recognise the same pattern in other questions. This eventually evolved into building mental models: connecting unfamiliar concepts to existing knowledge rather than collecting isolated facts. It’s an approach influenced by books like Make It Stick and How to Take Smart Notes, both of which argue that writing is a tool for understanding rather than simply recording information.

I like to write things down because it forces me to use my own words and highlights gaps in my understanding. It also encourages selectivity – since space is limited, every word must earn its place.

I’ve used several methods for this over the years, including:

  • Flashcard apps like Anki.
  • Ring binders with A4 notes and diagrams.
  • Blank A3 sheets as wall posters.

And now…

Pepe’s Whiteboard

Which brings us to my latest iteration and the reason for this post’s title – a whiteboard, several index cards and loads of fridge magnets:

DOPBoard600

While I could write directly on the whiteboard, the paper and magnets let me move, group, replace and reorganise cards without forcing a complete rewrite of the board.

This combines several benefits from the other systems:

  • Anki’s ease of note creation, tagging and movement.
  • The binder’s ease of writing notes on my own terms and in my own words.
  • The poster’s visibility and its ability to passively reinforce study material.

It also proved useful in the final days before the exam. Any cards that were still causing problems could be moved from the main board onto smaller, portable boards for targeted revision:

DOPBoardSmall600

This still has limitations, of course. It’s not portable as a complete knowledge source. The whiteboard also has limited space – in fact, I ultimately had to branch out to a nearby plastic box for overflow!

Despite the space constraints, I’m definitely a fan of this whiteboard approach and will use it for future exams. I might augment it with digital second brain tools like Obsidian or Google’s NotebookLM to inform what deserves a card, and I’ll be looking into this in the coming months.

Survival Tactics

This section examines some of my survival tactics for the AWS DevOps Engineer – Professional certification exam by optimising time, embracing personal kindness and checking my understanding.

The Maths is a Lie

The Professional exams have 75 questions with 180 minutes to answer them. This averages out at 2 minutes 24 seconds per question. In contrast, the Associate exams consist of 65 questions that must be answered in 130 minutes, averaging 2 minutes per question.

You may conclude from this that the Professional exam gives you a bit more breathing room. And you would be wrong.

I previously mentioned that the Professional questions are longer and more complex compared to the Associate questions. These factors quickly eat those ‘extra’ 24 seconds. Many candidates have noted anecdotally that the timing of the Professional exams is very tight and, having now taken one, I completely agree!

My preferred strategy is to go through the questions in order and get a quick gut feel for confidence. If the question involves services I frequently use, or if the answer is well established from my studies then I’ll answer it. If not, I flag it and move on. I’ll try to make this decision within 30 seconds.

My initial goal is to see all 75 questions with as close to 90 minutes remaining as possible. This way, when I reach the end of the questions, I know how many are unanswered and how long I have left to answer them. I can then revisit these questions using a more methodical approach, potentially drawing on other questions I have already answered.

However, this required a change to the way I recorded my progress…

Kindness Through Panic

Since my earliest certifications, I’ve used a Gut Feel system using my own notepad during mocks and the test centre’s whiteboards during exams. I create an empty table with three confidence ratings:

  • 100: I’m 100% sure of the answer.
  • 5050: I’ve narrowed it down to two answers.
  • ?: I have no idea.

As I move through the questions, each question number is recorded in one of these rows.

However, there’s nothing here for situations where I’ve speed-read the question and chosen not to answer it. The closest option was ‘?‘, but that means ‘I don’t know the answer’, whereas I wanted ‘I haven’t properly read the question‘.

Enter my latest addition: PANIC.

Panic is somewhat hard to articulate, so I’ll describe how I use it. A question will get Panic if my initial thoughts are along the lines of:

  • I’m currently panicking (I mean yeah – Ed).
  • I don’t want to try this question yet (for whatever reason).
  • I don’t feel ready to try this question yet (for whatever reason).

Or any other reason – this list isn’t exhaustive.

Professional exams are expensive, time-consuming and complex. It is completely reasonable to get adrenaline and anxiety in this situation. Panic lets me be kind to myself and build some forward momentum. I can then do second, third and fourth passes to attack the Panic queue.

It’s similar to an SQS queue visibility timeout. When a Panic question is pulled from the queue, it temporarily disappears. While it’s invisible, I can process other messages without it blocking my progress. Once I’ve completed my first pass, the timeout expires, the message reappears and I can handle it with fresher eyes and more context from the questions I’ve already answered.

At the end of an exam, I end up with something like this:

DOPPaper600

Combining this physical ledger with the exam software’s flagging feature lets me track unanswered questions and the reasons for skipping them. This gives me more mental bandwidth to actually answer the questions.

Hallucinations Aren’t Limited to AI

One of the biggest mistakes I repeatedly made during my mock exams was adding details that weren’t in the text. Who says AI is the only thing that can hallucinate?

I’ll illustrate what I mean with a paraphrased mock exam question:

A company has confidential files in an Amazon S3 bucket. Actions on objects need to be monitored, such as PUT, GET, and DELETE. The goal is to easily search for and review these actions for auditing purposes.

Four answers were provided. I narrowed it down to two options, one of which seemed wrong because it would trigger unnecessary Lambda executions.

But this answer was correct. And the reason my chosen answer would never have worked? It assumed a CloudTrail trail was already enabled on the bucket. The Lambda answer didn’t make that assumption, explicitly enabling the trail as a step. I’d hallucinated a prerequisite into existence because it’s what I’d have done instinctively in a real environment. Oops! This wasn’t the only time I caught myself out like that either.

So yes. Read the question. Then READ THE QUESTION. And then choose the answer that fits the requirements, not the one that needs some bending and stretching. And not the one that you’ve hallucinated into correctness.

Summary

Going into the AWS DevOps Engineer – Professional exam, I wasn’t sure what to expect. A harder version of the Associate exam? A different beast entirely?

As it turned out, both are true. The transition from Associate to Professional reminds me of the progress I’ve experienced in my own career. In my earlier roles, I primarily solved clearly defined problems with straightforward solutions. In my current consulting role, I concentrate on understanding context, navigating ambiguity, evaluating trade-offs and making decisions when no clear right answer exists.

While I did find the exam brutal, it does exactly what it sets out to do. I must often make important architectural and procedural decisions under time pressure and with appropriate justification, and the DevOps Pro held up a mirror to that perfectly. Would I do another? Absolutely. Although next time I might need a second whiteboard.

Like this post? Click the button below for links to contact, socials, projects and sessions:

SharkLinkButton 1

Thanks for reading ~~^~~

Categories
DevOps & Infrastructure

Installing A Drive Selector In An Amiga 500 Plus

In this post, I install a drive selector in my Amiga 500 Plus, letting it boot from USBs and a Gotek instead of floppy disks.

Introduction

So, remember that YouTube channel I started? Yeah – me neither.

Well, it’s back! I recently won an eBay auction for an external Gotek and Amiga 500 drive selector, and that gave me the nudge I needed to make a video!

eBayGotekAuction

This isn’t me chasing YouTube stardom. Rather:

In this post, I will cover some key concepts for those less familiar with 90s Commodore hardware, explain what happened during filming and then leave you with the finished video. Watch me flailing with drives and chips for 20 minutes!

Let’s begin with some explanations.

Some Key Concepts

Before jumping into the video, it’s worth covering the hardware and installation steps involved.

About Goteks

The Gotek floppy emulator was originally developed by Gotek System, based in Shenzhen, China, primarily for the industrial sector.

gotek pcb
A Gotek PCB

Original Gotek Design

The Gotek was originally designed to replace 3.5-inch floppy drives in legacy hardware such as CNC machines, aviation devices and musical workstations. Many of these machines depend on floppy disks for data input, making them difficult to operate as working floppy disks become harder to find.

The Gotek functions as a hardware bridge by emulating the electronic signals of a mechanical floppy drive. Instead of using physical disks, the emulator reads digital disk images from a standard USB flash drive. USB drives can store and manage multiple virtual disks, offering modern storage reliability without requiring invasive modifications to the host machine’s internal components.

gotek initial
Basic Gotek with three-digit navigation display & file selection buttons

Modern Gotek Usage

Gotek capabilities have greatly improved over time, thanks to people like Keir Fraser, the creator of the open-source FlashFloppy firmware. While basic Gotek models are still available, most enthusiasts now use FlashFloppy for compatibility with a wide range of vintage electronics.

Over the years, several Gotek models have been released. Current hardware options often include usability enhancements like OLED screens for clearer file navigation, rotary encoders for quick file scrolling and built-in speakers that mimic the seek sounds of traditional drives.

gotek modern
Modern Gotek with OLED navigation display and file selection rotary dial

About Drive Selectors

An Amiga drive selector is a device that switches the signals between the internal floppy drive and an external drive.

Why Are Drive Selectors Needed?

In the Amiga architecture, the internal floppy drive is designated as DF0, while external daisy-chained drives are assigned as DF1, DF2 and DF3. This hierarchy is fundamentally tied to how the hardware and software interact.

The earliest Amiga 500 models used Kickstart 1.3, which has no user-accessible way to select an alternative boot drive. Later Kickstart versions, starting with 2.0, introduced the option to select a boot drive through the early boot menu:

AmigaEarlyBootMenu

However, a significant issue remained: the software itself. A lot of classic Amiga software used custom trackloaders. These were low-level routines that bypassed AmigaDOS and read physical disk tracks directly. Developers used them to improve loading speed, reduce memory use and add copy protection.

By bypassing AmigaDOS, these NDOS (Non-DOS) disks could:

  • Load faster by reducing drive head movement.
  • Conserve memory by not loading the full OS disk-reading library.
  • Prevent piracy through non-standard disk formatting.

The downside was that many of these disks were hard-coded to expect DF0. Even if a program was launched from DF1, it might still look for files or data on DF0. If DF0 was empty, the Amiga would crash or simply hang.

That is where a drive selector becomes useful. Rather than changing the software, the selector changes the hardware’s view of the drives.

How Drive Selectors Operate

Drive selectors are available as switched and switchless versions. Mine is from AmigaStore.eu, judging by the PCB markings.

To understand how a drive selector works, one must look at the 8520 CIA (Complex Interface Adapter) chips on the Amiga motherboard. Specifically, CIA-A (located at address $BFE001) is responsible for handling the floppy disk interface signals, including the Drive Select lines.

cia even
An Even CIA Chip

Upon boot, the Amiga identifies which drive to talk to using four active-low Select signals: _SEL0, _SEL1, _SEL2, and _SEL3.

  • _SEL0 triggers the internal drive DF0.
  • _SEL1 triggers the first external drive port DF1.

A drive selector sits between the CIA-A chip and its socket. It intercepts the relevant traces and swaps the logic lines when activated:

  1. The _SEL0 signal coming from the CIA is routed to the motherboard’s DF1 circuitry.
  2. The _SEL1 signal is routed to the internal DF0 circuitry.

Because this happens electrically before the signal reaches the drive cables, the Amiga does not know anything has changed. It still believes it is talking to the internal drive, but the signal is actually being redirected to the external Gotek.

That gives a level of compatibility that software-based drive remappers cannot always match. Even persistent trackloader-based software will treat the Gotek as if it were an internal drive.

SelectorFitted
A fitted drive selector and switch

Video

Here’s the full video walkthrough of the install – droppages, shark noises and all!

Video Summary

In the video, I open my 1991 Amiga 500 Plus and install a drive selector PCB. I took a fairly quick-and-dirty approach and worked around the internal components, but in hindsight I should have removed the floppy drive entirely to give myself more room.

The installation involves carefully removing the Even CIA chip from its socket on the motherboard. I then connect the drive selector PCB to the original 40-pin socket and place the chip into the selector.

After that, I test the setup with an Amiga Test Kit floppy disk and a Cannon Fodder ADF. The selector successfully redirects the DF0 boot signal to the external Gotek, letting me boot from USB while keeping the original internal floppy drive fully functional.

This is not presented as the optimal method – retro hardware can be unpredictable, and a cleaner approach would involve removing more components before starting.

Video Chapters

If you prefer, you can jump to specific sections using the chapters below.

  • 00:00 – Introduction
  • 02:08 – Explaining the DF0/DF1 boot problem
  • 02:53 – The Drive Selector PCB & Toggle Switch
  • 03:59 – Opening the Amiga (Safety First!)
  • 04:32 – Identifying the Even CIA Chip (U8)
  • 06:04 – The delicate art of chip extraction (and bending pins)
  • 10:54 – Amiga 500+ Hardware: Agnus, Denise, and current values
  • 12:37 – Installing the Switcher & Re-seating the CIA
  • 16:35 – The first boot & a mysterious Guru Meditation
  • 18:46 – Success! Testing with Amiga Test Kit
  • 20:05 – Final Demo: Loading Cannon Fodder from the Gotek

Technical Errata & Clarifications

  • 02:08 – I called it a “Godrive,” I meant Gotek.
  • 09:25 / 10:11 – I mentioned “bent chips” – I meant the metal pins/legs!
  • 11:14 – Confirming: The 8375 Agnus is the 2MB Chip RAM version. Standard A500 Agnuses (8370/71/72) only support 512KB or 1MB.
  • 17:15 – The Guru Meditation was likely a seating issue with the CIA adapter. If the pins aren’t making perfect contact, the CPU will throw this error immediately.
  • 17:53 – The ticking sound is the stepper motor resetting to track 0. It has nothing to do with the drive heads.

Plus I erroneously call it a ‘Drive Switcher’ throughout. Oops.

Summary

In this post, I installed a drive selector in my Amiga 500 Plus, letting it boot from USBs and a Gotek instead of floppy disks.

I had fun with this! Which was the point! It was a chance to work on something familiar in a cosy space, and get more comfortable on camera while doing it. This and the recent Kubernetes lab reminded me why I like retro projects so much: they are practical, technical and just unpredictable enough to keep things interesting.

Like this post? Click the button below for links to contact, socials, projects and sessions:

SharkLinkButton 1

Thanks for reading ~~^~~

Categories
DevOps & Infrastructure

Resurrecting A 2011 PC Into A Kubernetes CKA Lab

In this post, I document the journey of resurrecting a dusty old 2011 PC into a functional Kubernetes lab to prepare for my CKA exam.

Introduction

This year, I plan to take the Certified Kubernetes Administrator (CKA) exam. I’m familiar with tech certifications, having earned my first one in 2019. However, the CKA differs from these exams in that it is a performance-based test that requires completing multiple tasks from the command line with Kubernetes.

I’ve been using Mumshad Mannambeth’s Udemy course, and while it includes several labs I also want to get some extra practice. So I started looking into setting up a Kubernetes lab, and found that I already had access to several devices capable of running one! I have since successfully created my lab, and this post examines how I got there.

I’ll begin by explaining my decision to use the 2011 PC for my Kubernetes lab over other available options, as well as the repairs it needed to get going. Next, I’ll describe the process I followed to select a suitable operating system. Finally, I’ll outline the steps taken to test the PC and install the necessary lab components.

Hardware Selection

In this section, I explain why I chose the 2011 PC for my Kubernetes lab over other available options. While this may seem redundant given the blog title, I wanted to share my considerations and thought processes.

I considered three options:

  • Raspberry Pi Cluster
  • Amazon EC2 Instances
  • A 2011 PC

Raspberry Pi Cluster

The Raspberry Pi is a compact single-board computer widely used for building low-power projects and clusters. It enables users to run Linux and explore different architectures, providing an efficient way to learn about distributed systems without the energy costs of traditional servers.

While the humble Pi may not be the most obvious choice for a Kubernetes lab, a Kubernetes Up & Running appendix covers building a Kubernetes cluster on Raspberry Pi. So it was worth considering!

Raspberry Pi Cluster Pros

  • No Virtualisation Overhead: Running Kubernetes on bare-metal Raspberry Pis removes the need for a hypervisor, allowing all ARM processor cycles and RAM to be fully dedicated to the lab.
  • True High Availability Testing: A Raspberry Pi cluster uses a “shared-nothing” architecture. Unplugging a node forces the cluster to demonstrate its real-time self-healing capabilities.
  • Energy Efficiency: While an old PC draws 60W–100W, a 3-node Pi cluster runs on under 15W. This makes 24/7 operation significantly cheaper.

Raspberry Pi Cluster Cons

  • High Capital Expense: A starter kit with nodes, reliable power supplies and network gear easily exceeds £100 in 2026. I already own a Pi 4, but I’d still need everything else.
  • Component Rigidity: Unlike a desktop PC with swappable RAM, Pi memory is soldered in place. Increasing a Pi’s RAM requires a complete hardware refresh, which limits the lab’s long-term lifecycle.
  • Storage Fragility: Constant logging in Kubernetes can degrade standard microSD cards within months. Reliable operation usually requires booting from USB SSDs, which increases both cost and physical clutter.

EC2 Instances

Amazon EC2 is a standard service for on-demand virtual servers that lets users rent computing capacity in AWS data centres. It operates on a “pay-as-you-go” model, allowing users to launch and terminate instances with the required CPU and RAM as needed.

Note that Amazon also provides Elastic Kubernetes Service (EKS). However, EKS is a managed service and I want to practise the manual Kubernetes setup process.

EC2 Pros:

  • Production Parity: EC2 offers a realistic environment with the same features and specs as a professional enterprise deployment.
  • On-Demand Scalability: Complex node architectures can be quickly created or deleted, enabling the testing of scenarios that would take hours to set up on physical hardware.
  • No Hardware Maintenance: The cloud provider manages the entire bare-metal abstraction. Users are not responsible for managing the hypervisor, physical cooling or local network switching.

EC2 Cons:

  • Ongoing Costs: Even small t3.micro instances accumulate costs quickly. A three-node lab running 24/7 would eventually cost more than the other options.
  • Reduced Learning Opportunities: AWS manages most of the backend networking. This limits opportunities to learn about topics such as network bridges, VLANs or physical NIC teaming.
  • Internet Dependency: The lab’s reliability depends on my home internet connection. If it drops, the entire cluster is unreachable.

A 2011 PC

The time has come. Meet the HP Pavilion p6-2022uk:

Tower 700
The joys of photographing something with black shiny plastic – Ed

This BEAST originally shipped in 2011 with specs including:

  • Processor: Intel Core i3-2120 (3.3 GHz, Sandy Bridge)
  • Memory: 4 GB DDR3-SDRAM (1333 MHz), 2 slots
  • Storage: 1 TB HDD (typically 7200 RPM)
  • Operating System: Windows 7 Home Premium 64-bit
Internals 700

On the back are four of the PC’s six USB 2.0 ports (none of your fancy USB 3.0 here), three audio ports, VGA and DVI outputs (no HDMI) and the Ethernet port:

Rear 700

So how does it stack up?

HP Pavilion Pros:

  • No Capital Expense: Turning existing hardware into a learning tool prevents e-waste and incurs no cost.
  • Full Hardware Control: The PC provides full access to the hardware BIOS, the physical network stack and the hypervisor kernel. This offers an in-depth understanding of how the lab works.
  • Expandability: The PC allows for modular upgrades, making it easy to add more RAM, replace a hard drive or install new network and graphics cards. In contrast, these upgrades can be challenging or even impossible with a cluster of Raspberry Pis.

HP Pavilion Cons:

  • Power Inefficiency: The PC must stay on while the lab operates. This will use more power than the other options, and the power supply, which is from 2011, may be less efficient than modern ones.
  • Legacy Components: The ageing processor, RAM, and ports mean that using the PC will not offer as smooth an experience as a group of Raspberry Pis or EC2 instances. It will lack speed, portability, and hardware redundancy.
  • Repairs Needed: So this leans into why I have this PC in the first place. It do be poorly!

Its biggest problem is the hard drive, which currently boots to an imminent failure warning before failing entirely:

HardDrive 700

The WiFi card is also unreliable. This wasn’t a major issue in the past because it was positioned next to the router and had a constant Ethernet connection. However, this limited its placement options, and it poses a problem now.

Hardware Decision

So why, with all these negatives, did the PC win? It came down to control, simplicity and cost.

Infrastructure Control

With a single physical device, I have complete control over every layer of the stack. I can customise the storage, upgrade the RAM or change the internals whenever necessary. This is impossible with a Pi cluster and limited with EC2 instances.

Minimal Operational Complexity

A PC simplifies everything by combining all components into one device, eliminating the need to manage multiple setups. This way, I can focus on learning Kubernetes instead of juggling cables and managing security groups.

Cost Efficiency

Using a PC lets me avoid the high capital expenditure costs of a Raspberry Pi cluster or the ongoing operational expenses of EC2. Instead, I can invest in repairs and upgrades for the PC and eventually replace it when it fails.

Next, let’s get onto those repairs!

Repairing The PC

If this 2011 PC is going to run Kubernetes, it needs some repairs! In this section, I’ll triage the PC and attempt to fix its issues. For clarity, those issues are prioritised in the following order:

  • Dead hard drive
  • Low RAM
  • Questionable WiFi card

Hard Drive Replacement

Addressing the biggest problem first, that knackered hard drive must go! While fixing hard drives isn’t impossible, it needs specialised skills and is labour-intensive. And in this case, it’s not worth the effort. There’s nothing valuable on the drive, and due to its age it could fail at any moment. That makes this a replacement job!

Thankfully, I made this decision a while ago – well before the current hard drive cost spike! I realised I needed neither an SSD’s speed nor a terabyte of storage. So I bought a Seagate Barracuda ESA-3502 500 GB HDD as it reviewed well and came in at a bargain price of £19.99 (as opposed to the current £35.99 asking price!)

RAM Upgrade

Next, let’s talk about RAM. Although Kubernetes can operate with just 4GB of memory, the virtual machines and the PC also require some memory to function properly. Having such a low memory limit will lead to various problems. The VMs may become too slow, and the PC itself might encounter performance issues.

Over the years, I’ve owned many computers. And like many people in the IT profession, I have various cables, heat sinks, and parts salvaged from computers that were destined for the scrap heap!

Among these items, I found two 8GB DDR3 RAM sticks which I swapped for the PC’s two 2GB sticks. Now this may not work, as the PC’s specs specify that each slot’s maximum memory capacity is 4GB. No harm in trying though, eh?

Internet Access

Finally, let’s discuss the WiFi situation. The WiFi card is already known to have issues, and the PC is on a different floor from my home router so I can’t use Ethernet. This won’t affect the operating system installation, as both the USB ports and the optical drive work. But I won’t then be able to download any updates, firmware or the various Kubernetes components.

Enter my Raspberry Pi 4! This is fully capable of connecting to my WiFi and sharing that connection with my PC. It acts as a NAT (Network Address Translation) router, managing the communication between its wireless interface (wlan0) and its wired Ethernet interface (eth0). This setup is similar to how a home router shares a single public IP address among multiple devices.

Here is what happens at the network layer:

  • The Pi connects to the WiFi network via wlan0 and receives an IP address from the router (e.g. 192.168.1.12). The router sees the Pi as another wireless client.
  • The Pi assigns itself a static IP on eth0 in a separate subnet (e.g. 10.0.0.1) and runs a small DHCP server on that interface via dnsmasq. The PC will use this network.
  • The Pi and PC’s Ethernet ports are then wired together.
  • When the PC sends traffic intended for the internet, it is routed to the Raspberry Pi, which serves as its default gateway.
  • The Raspberry Pi modifies the packet’s source IP address to match its own wlan0 address before forwarding it upstream. This process is known as NAT Masquerading.
  • Incoming replies are received by the Raspberry Pi, which translates the IP addresses back to their original format and then forwards them to the PC.
PiNAT 600

That’s everything! The PC should now boot. But boot what?

OS Selection

As I’m replacing the PC’s hard drive, I can also upgrade the operating system. Since I plan to run virtual machines on the 2011 PC for my Kubernetes nodes, the host OS will act as a hypervisor.

It will handle three critical tasks:

  1. Resource Management: Allocating CPU and RAM for each VM.
  2. Storage: Managing how the VMs access the physical hard drive.
  3. Networking: Creating a bridge so VMs can talk to each other and the internet.

Keep in mind that the OS selections for the 2011 PC and for the Kubernetes VMs are independent choices and needn’t be the same. For instance, Windows can run WSL, and a Debian host can run Ubuntu VMs. The decision on the VM OS will be made after the host OS has been determined.

Let’s start with the traditional players. Which, it turns out, aren’t all that suitable…

Windows

Windows is the most widely used desktop OS and provides a professional-grade virtualisation platform through Hyper-V. While it is a strong option for running enterprise mixed-OS environments, its architecture is poorly suited for a dedicated Linux-based lab on legacy hardware.

  • Tooling Incompatibility: The standard open-source orchestration stack, including virt-manager, cloud-init, and virsh, is designed for the Linux/KVM ecosystem. Managing a Windows host on the 2011 PC needs a distinct set of PowerShell tools, adding unhelpful complexity to the learning process.
  • Resource Inefficiency: A Windows host uses a significant amount of RAM and CPU cycles to operate its GUI and background telemetry. On a dual-core i3-2120 with 4GB of RAM, this operational overhead leaves less room for the guest VMs.
  • Storage Latency: The NTFS file system, along with Windows’ aggressive background indexing and telemetry, creates significant disk contention. This latency becomes more pronounced on older mechanical drives, leading to slower boot times and reduced responsiveness for virtual disk images.

macOS

macOS is well known for providing an exceptional developer experience and is the primary OS used by many in the DevOps community. However, its kernel is optimised for use as an interactive workstation rather than as a persistent, headless hypervisor host.

  • Kernel Abstraction: macOS does not have a built-in hypervisor compatible with Linux, so tools like Docker Desktop or Lima must run a helper VM to create a Linux environment. This results in nested virtualisation, where one VM runs inside another, complicating networking and reducing performance.
  • Architecture Mismatch: Most production Kubernetes clusters are designed for amd64 architecture. Running amd64 nodes on an Apple Silicon Mac involves using QEMU for emulation. This method reduces performance and can introduce subtle behavioural bugs in low-level networking and storage drivers that don’t appear on native hardware.
  • Hardware Inflexibility: macOS is optimised for interactive power management. When used as a persistent, headless server, the OS often deprioritises background tasks or enters sleep states. This can disrupt the high-availability heartbeats needed by a Kubernetes cluster.

Linux

Linux is the industry standard for virtualisation. KVM (Kernel-based Virtual Machine) is built directly into the Linux kernel, making virtualisation a primary feature rather than an additional component. Linux also spotlights the key components used by both hypervisors and Kubernetes: namespaces, cgroups, and network bridges, without the licensing issues of proprietary operating systems.

Linux has many distributions, each with its own package manager, default software and design philosophy. I considered the following Linux distros:

Alpine Linux

Alpine is designed for minimal-footprint environments where reducing attack surface and efficient resource use is crucial. It serves as the base image for many public Docker containers and is employed in embedded systems and security-focused infrastructure, where any unnecessary package can pose a risk.

Alpine Pros
  • Extreme Resource Efficiency: Alpine generally uses 50-80 MB of RAM while idle. This optimisation reduces host-level overhead on older hardware, maximising resources for guest VMs.
  • Reduced Attack Surface: Alpine minimises potential attack vectors by removing unnecessary binaries and packages.
  • Lightweight Init System: It uses OpenRC instead of systemd, resulting in quicker boot sequences and service management through transparent shell scripts.
Alpine Cons
  • GNU Toolchain Friction: Alpine replaces the standard GNU utilities with BusyBox. However, resources such as the KVM documentation assume GNU, so commands must be translated for BusyBox.
  • Standard Library Divergence: The use of musl libc instead of glibc can lead to silent failures and unexpected problems with precompiled binaries or certain kernel modules.
  • Manual Configuration: In Alpine, certain administrative tasks that are automated in other distributions, such as kernel module persistence and complex network bridging, require manual intervention.

Debian Linux

Debian is designed for stable, long-term server infrastructure, prioritising predictability over having the latest software. It serves as the foundation for several distros, including Ubuntu and Raspberry Pi OS, and has built a reputation based on a careful release process that emphasises reliability.

Debian Pros
  • Predictable Performance: A minimal Debian installation uses less than 200MB of RAM. Its lack of unnecessary background processes reduces disk I/O contention on mechanical hard drives, which is vital when multiple VMs are swapping.
  • Streamlined Architecture: Debian avoids using the snapd daemon and its loop-device overhead. This method keeps the host’s kernel routing table and mount points organised, simplifying the troubleshooting of VM network bridges.
  • Universal Binary Compatibility: Debian uses the standard glibc library. This compatibility allows enterprise virtualisation tools and guest agents to run natively without extra layers. As a result, Debian can use Ubuntu’s software ecosystem while minimising the associated service overhead.
Debian Cons
  • Manual Installation: Debian’s installer requires careful decisions about partitioning and mirror selection, as misconfigurations can cause issues.
  • Firmware Hurdles: Although hardware detection has improved, proprietary firmware for older network and WiFi cards may still need to be manually included from the “non-free” repository during initial setup (although from Debian 12 onwards this is less of a problem than it used to be).
  • Conservative Packaging: Debian prioritises stability over the latest software versions. Accessing the latest QEMU or libvirt features occasionally require the use of the backports repository.

Ubuntu Linux

Ubuntu is the most popular Linux distribution used in cloud and server environments. It is often the default choice referenced in DevOps and Kubernetes documentation. Commercially supported by Canonical, Ubuntu has a regular release schedule and offers long-term support versions suitable for both enterprise and home users.

Ubuntu Pros
  • Native Documentation Sync: Most KVM and libvirt guides are written with Ubuntu in mind. File paths and package names at the host level will closely align with the most common reference materials.
  • Extensive Driver Support: Ubuntu’s Hardware Enablement (HWE) stack includes proprietary drivers by default. This guarantees that niche hardware components on older PCs will work right away, eliminating the need for manual troubleshooting.
  • Commercial Maturity: Ubuntu provides a regular release schedule and strong community support for troubleshooting complex virtualisation scenarios such as GPU passthrough and nested virtualisation.
Ubuntu Cons
  • Service Overhead: The inclusion of snapd, cloud-init and automated update daemons result in an idle footprint of 300–400 MB. On hardware with low RAM, this consumes vital memory before a single VM starts.
  • Network Abstraction: Ubuntu uses the Netplan abstraction for network configuration. This adds a layer of YAML complexity as opposed to the direct control of the traditional /etc/network/interfaces file.
  • I/O Latency: Background services like unattended-upgrades can trigger sudden changes in disk activity. On older mechanical drives, this can cause guest VMs to experience latency spikes during high-load operations.

OS Decision

For my 2011 PC Kubernetes lab, Debian is the optimal choice. While Alpine is leaner and Ubuntu is more automated, Debian provides the best performance-to-stability ratio for a 2011-era PC acting as a VM host.

CPU and I/O Contention

Debian offers a more stable environment with fewer background processes compared to Ubuntu. This is particularly useful for a PC with an Intel i3-2120 dual-core processor, as it reduces the number of running daemons and minimises disk activity. This will improve VM performance and Kubernetes cluster stability.

Fastest Success Path

Debian occupies a sweet spot between Ubuntu’s excess and Alpine’s frugality, letting me set up a Kubernetes lab quickly without making significant changes to the OS.

Hypervisor Consistency

A hypervisor host functions best on a reliable foundation. Debian’s stable release offers fixed package versions and a cautious update policy, ensuring that the KVM toolchain, network bridge drivers and configurations stay consistent. This stability prevents version drift that could disrupt networking or storage for the guest VMs.

Testing Old PC

In this section, I conduct a smoke test of the 2011 PC and Debian to check that my repairs were successful and that the system is stable enough for virtualisation and Kubernetes.

Hard Drive Test

The first test is the simplest. When activated, the PC immediately detects the replacement hard drive. It then uses my Debian USB to run the installer, progressing through each stage without issue.

I’m installing Debian 13 – the most recent version, released on 9 August 2025. For those curious, this video shows a typical Debian 13 installation:

I mentioned earlier that the installer requires some careful decisions. One of these is the choice of Debian desktop environment:

2026 01 30 10 43 04 DebianSoftwareSelection

There are several choices here that control how minimal or feature-rich the desktop is. Many guides recommended the bare minimum SSH server to maximise the resources available for Kubernetes. I chose to install Xfce – a lightweight GUI designed for older or limited-resource hardware. This will let me see the various Debian backend files and folders in a familiar Windows-like environment, helping me understand Kubernetes’ inner workings.

This video explores several Debian desktop environments, including Xfce:

RAM Test

Next, let’s assess the RAM. This was partially verified during the hard drive test, as faulty RAM would have either caused issues during the Debian installation or prevented the PC from booting outright. But how much RAM is actually available?

With a successful Debian install, I can run free -h to find out! This shows 15GB memory with 14GB free:

2026 01 31 16 39 40 free

This is…interesting given the PC’s stated maximum of 8GB! Indeed, running dmidecode to query the BIOS states that the maximum capacity is 8GB:

2026 01 31 16 37 06 dmidecode

Having researched, there are two main reasons for this:

  • Outdated BIOS Info: The motherboard’s DMI table, which dmidecode uses for information, was created when 4GB sticks were the known maximum limit, and HP never updated it.
  • Ambiguous Definition: Sometimes “Max Capacity” refers to the per-slot maximum rather than the entire board‘s total. And there are two devices (slots), so 2x 8GB is 16GB.

In any case, free -h can be trusted so I do indeed have 16GB RAM!

I can also use lscpu to verify how many cores the PC has. The Intel Core i3-2120 is a dual-core processor with two physical cores. It features Intel Hyper-Threading, allowing each core to present two threads (logical processors) to the OS, resulting in a total of four threads.

2026 01 31 16 40 22 lscpu

Internet Test

Finally, let’s test the internet. Running ping -c 4 8.8.8.8 in the terminal returned packets successfully, and running sudo apt update fetched the latest package list:

2026 03 14 wifitest

With everything set up, there’s just one step remaining to convert my 2011 PC into a Kubernetes lab.

Configure Virtualisation

In this section, I outline the steps taken to install the software needed for the 2011 PC to function as a hypervisor in my Kubernetes lab. Please note that I do not claim this to be the definitive or best approach; it simply reflects my process for getting everything up and running on this occasion.

Installing Libraries

It’s now time to equip Debian with the necessary tools for virtualisation. This resulted in a fairly large install command, with each component contributing to my lab’s stability and manageability.

Bash
sudo apt install -y \
  qemu-kvm \
  bridge-utils \
  libvirt-daemon-system \
  libvirt-clients \
  virtinst \
  libosinfo-bin \
  virt-manager \
  virt-viewer

So, what is all this actually doing? Let’s examine in stages.

Core Components

qemu-kvm: This forms the core of the entire system. KVM is a Linux kernel module that lets a CPU run VMs at speeds nearly matching those of physical hardware. QEMU manages the rest of the hardware emulation, providing the virtual motherboard, disk controllers and network cards that the guest OS recognises as genuine. Together, these components turn a PC into a platform capable of hosting multiple VMs.

bridge-utils: While VMs are isolated by default, bridge-utils creates a virtual switch that links them directly to a physical network. This is crucial for a Kubernetes lab, as it allows each node to obtain its own IP address and route traffic through the Raspberry Pi bridge. By using the host’s Ethernet connection in this way, the VMs gain the stable internet access required for cluster orchestration and updates.

Lifecycle & Control

libvirt-daemon-system: This package operates as a daemon responsible for managing VM lifecycles. It monitors active nodes, controls startup and shutdown processes, and ensures that a VM crash does not impact the entire system.

libvirt-clients: This provides the command-line tools needed to interact with libvirt-daemon-system, most notably including virsh – an industry-standard utility for managing VMs via the terminal. It can check statuses, modify configurations and reboot nodes from the terminal.

Provisioning & Optimisation

virtinst: This package yields virt-install, a command-line tool for creating VMs. Instead of going through a wizard multiple times, one command now specifies the CPU, RAM, and disk for multiple nodes. This makes setting up Kubernetes nodes quick and repeatable.

libosinfo-bin: Virtualisation works best when the host has detailed knowledge of the guest OS. This tool serves as a database that guides the hypervisor in using appropriate high-performance drivers for each VM. This technique allows the main CPU to conserve its cycles by reducing reliance on inefficient hardware emulation.

Monitoring & Troubleshooting

virt-manager: Although the primary goal is to manage the VMs through the terminal, I also want a GUI as I familiarise myself with the system. Virt-manager offers a graphical interface to monitor CPU and RAM usage in real time.

virt-viewer: If a VM fails to boot or loses its network connection, SSH access is impossible. This package opens a window that displays the VM’s console, allowing users to troubleshoot the boot process or fix a broken config file as if accessing it directly.

Testing Virtualisation

Having installed everything, I now need to test that the hypervisor works. On Debian, installing the packages doesn’t always mean the services are active and ready to run. So firstly I need to start the virtualisation daemon manually:

Bash
sudo systemctl enable --now libvirtd

And then check virtualisation is running:

Bash
sudo systemctl status libvirtd --no-pager

It should show a green active (running) status. But…uh oh.

2026 02 05 14 51 24 MissingVirtualisation

This error means virtualisation isn’t enabled. And that means a trip to the PC’s BIOS settings!

2026 02 07 18 32 36 BIOSVirt

With VTx enabled and a reboot later, the libvirtd service is now active:

2026 02 05 14 54 40 VirtOK

Running kvm-ok (installed via cpu-checker)also shows the PC can now host hardware-accelerated KVM virtual machines. I can now run virt-manager to load the GUI:

2026 02 05 14 55 52 kvm

This loads the Virtual Machine Manager, from which I can create and interact with my VMs via a GUI:

2026 02 05 14 56 29 VirtualMachineManager

My 2011 PC can now spin up some Kubernetes nodes!

In terms of next steps, I’ll use the Kubernetes documentation to turn the 2011 PC into a multi-node cluster. The CKA is open-book, and getting familiar with the documentation will be a massive help during the exam!

Summary

In this post, I documented the journey of resurrecting a dusty old 2011 PC into a functional Kubernetes lab to prepare for my CKA exam.

This experience was a nice blend of familiar and new. While I’ve worked extensively with Linux, I’ve not gone into the weeds with various distros before. Nor have I built my own NAT router! Ultimately, this was a fun and engaging project and I’m looking forward to kicking the tyres of my new lab!

Like this post? Click the button below for links to contact, socials, projects and sessions:

SharkLinkButton 1

Thanks for reading ~~^~~