One of my current homelab projects is less about building the fastest server possible and more about figuring out just how much useful infrastructure I can build from inexpensive, low-power, and sometimes completely free hardware.
Rather than buying a large rack server and feeding it several hundred watts around the clock, I have been collecting small systems that might otherwise be overlooked.
Right now, the lab consists of:
- Four Lenovo ThinkCentre M73 Tiny PCs
- One HP ProDesk 600 G1
- One mATX X99 DDR3 system
- Two older laptops that I received for free
- One used LGA 1155 desktop that I also received for free
Some of these machines are more capable than others, and not all of them may ultimately earn a permanent place in the cluster.
That’s part of the project.
The first step is simply testing everything.
The Goal: Make Old Hardware Useful Again #
My goal isn’t to create a traditional enterprise cluster using identical servers.
In fact, almost the opposite.
I want to find out how effectively I can combine cheap, used hardware into a useful little Proxmox environment while keeping power consumption, cost, heat, and noise relatively low.
The Lenovo M73 Tiny systems are particularly interesting for this.
They are small enough that several of them can fit into the space occupied by a normal desktop computer, use inexpensive DDR3 memory, and support Haswell-era CPUs that are still perfectly capable of running lightweight server workloads.
Four of them together start becoming much more interesting than any one machine individually.
Instead of asking:
How powerful is this old Tiny PC?
The better question becomes:
What can four or five of these machines accomplish together?
That is what I want to explore.
Four Lenovo M73 Tiny Nodes #
The heart of the experiment will likely be my four Lenovo ThinkCentre M73 Tiny PCs.
These are older one-liter business desktops built around Intel’s LGA 1150 generation.
They aren’t particularly exciting as modern desktop computers, but that isn’t what I need them to be.
For a homelab, they have several things going for them:
- Low idle power consumption
- Small physical footprint
- Cheap DDR3 memory
- Inexpensive replacement parts
- Gigabit Ethernet
- Support for capable four-core Haswell processors
- Enough performance for lightweight virtual machines and containers
I’m currently testing all four systems and determining exactly what hardware each one contains.
I’ll also be experimenting with CPU and memory upgrades where they make financial sense.
The important part of this project is value.
There isn’t much reason to put an expensive processor into a computer that was purchased cheaply if a $10 or $20 CPU will accomplish the same server workload.
I want to find the point where inexpensive hardware stops being merely old hardware and starts becoming genuinely useful infrastructure.
The HP ProDesk 600 G1 #
Alongside the Lenovo machines is an HP ProDesk 600 G1.
It comes from roughly the same hardware generation, which makes it a useful addition to the project.
One of the things I like about using older enterprise desktops is how much hardware was produced during this period. Lenovo, HP, and Dell sold enormous numbers of Haswell-era business PCs.
That means CPUs, memory, power supplies, adapters, and replacement systems remain readily available on the used market.
The HP doesn’t have to be identical to the Lenovo nodes to participate in the lab.
Proxmox makes it possible to manage different hardware configurations as part of the same cluster, allowing the ProDesk to become another compute node with its own capabilities and limitations.
That heterogeneous nature is something I actually want to embrace.
The X99 DDR3 Machine #
I also have an mATX X99 system using DDR3 memory.
This machine is considerably different from the Tiny PCs.
Where the M73s are focused on efficiency and small workloads, the X99 platform gives me access to inexpensive Xeon processors with much higher core counts and significantly more memory capacity.
That makes it a natural candidate for workloads that don’t fit particularly well on the smaller machines.
The Tiny PCs might handle several small infrastructure services while the X99 system handles a larger virtual machine, game server, database, compilation job, or other CPU- and memory-heavy workload.
That creates an interesting cluster design.
Instead of several identical servers, I can potentially have a group of small efficiency-focused nodes surrounding one larger compute node.
In other words, the X99 machine can become the heavyweight of the mini lab.
Then There Are the Free Computers #
Some of the most interesting machines in the project cost me nothing.
I currently have two older laptops and an LGA 1155 desktop that I received for free.
I haven’t decided exactly what each one will do yet.
And that’s part of the fun.
Old computers are frequently considered useless simply because they no longer make particularly good modern desktop computers.
Server workloads are different.
A machine doesn’t need to run a modern desktop environment, dozens of browser tabs, office applications, and a pile of background processes just to be useful.
Take away the graphical desktop and suddenly an older computer has considerably more resources available for doing actual work.
A second- or third-generation Intel Core system may be unimpressive as a daily-use desktop in 2026, but it can still be perfectly capable of running:
- DNS
- Monitoring
- Web services
- Databases
- Automation tools
- Docker containers
- Development utilities
- Small game servers
The laptops are particularly interesting because they effectively come with their own monitor, keyboard, and miniature UPS.
A battery that might be annoying in a normal daily-use laptop can actually become useful in a homelab because it can provide some protection against brief interruptions in power.
Whether all of these systems become permanent cluster nodes remains to be seen.
For now, the goal is to test them and figure out where they are useful.
Proxmox Will Tie Everything Together #
The long-term plan is to turn the useful systems into a Proxmox VE cluster.
Proxmox gives me a centralized management interface for a collection of otherwise very different computers.
Instead of treating every machine as its own isolated server, I can manage the lab as a group of compute resources.
From a browser, I’ll be able to manage:
- Proxmox nodes
- Virtual machines
- Containers
- Storage
- Backups
- Resource utilization
- Networking
- Cluster health
The cluster doesn’t magically combine every CPU and stick of RAM into one giant computer.
Each workload still runs on an individual physical host.
What Proxmox provides is the management and virtualization layer that makes those machines much easier to organize.
If one M73 has spare capacity, I can give it another workload.
If something needs considerably more memory or CPU cores, it might belong on the X99 system instead.
That flexibility is exactly what I want.
Ubuntu Server Without a GUI #
Most of the actual services inside the cluster will run on Ubuntu Server without a graphical interface.
There is very little reason for my server workloads to waste memory and CPU cycles rendering a desktop nobody is going to look at.
My general architecture will look something like this:
Physical Hardware
│
▼
Proxmox VE
│
▼
Ubuntu Server VM
(No GUI)
│
▼
Docker
│
▼
Applications / ServicesEach layer serves a different purpose.
Proxmox manages the physical infrastructure and virtual machines.
Ubuntu Server provides a familiar, lightweight Linux environment.
Docker packages and separates many of the individual applications.
I also like this architecture because it makes experimentation much safer.
Instead of installing dozens of applications directly onto the Proxmox hosts, I can keep the hypervisors relatively clean.
The services live inside Ubuntu Server systems, and Docker further separates many of those applications.
If I break something while experimenting, I would much rather break a disposable VM or Docker container than the underlying hypervisor.
Docker All the Things… Within Reason #
Docker is going to play a major role in this lab.
A surprising number of homelab applications can run comfortably inside containers with very little overhead.
Potential workloads include:
- Monitoring tools
- Web applications
- Reverse proxies
- Dashboards
- Databases
- Automation services
- Development environments
- Game-server-related infrastructure
- Management utilities
Not every application needs its own physical computer.
It doesn’t even necessarily need its own virtual machine.
Several smaller Docker containers can coexist comfortably inside a modest Ubuntu Server VM.
That is where the Tiny PCs become particularly useful.
An M73 doesn’t need to replace an enterprise server.
It just needs enough resources to reliably host a handful of useful services.
Multiply that by four machines and the available capacity starts adding up.
Building Around Failure #
One thing I want to keep in mind while building this lab is that this is old hardware.
Some of it is more than a decade old.
Eventually, something will fail.
That isn’t necessarily a reason not to use it.
In some ways, it makes the project more interesting.
If an inexpensive Tiny PC dies, replacing the entire node may cost less than replacing a component in a modern server.
A cluster also gives me an opportunity to design services so that the failure of one physical computer doesn’t have to be catastrophic.
Backups, configuration documentation, virtualization, containers, and eventually some level of workload redundancy can make the individual physical computer much less important.
The hardware becomes replaceable.
The services are what matter.
That is a philosophy I want this lab to gradually move toward.
Performance Per Dollar — and Per Watt #
I spend a lot of time looking at old Xeons, used business desktops, DDR3 memory, and inexpensive enterprise hardware.
There is a tremendous amount of perfectly functional computing hardware available for very little money.
The challenge is deciding where the price-to-performance curve actually makes sense.
A high-core-count Xeon sounds great until the server consumes a large amount of electricity while doing almost nothing.
A Tiny PC with a low-power processor may not sound particularly exciting until you realize it can quietly run several services while consuming very little electricity.
For a machine that might eventually run 24 hours a day, idle power consumption matters.
That’s another reason I’m interested in building the lab around several small systems rather than relying exclusively on large servers.
It also creates the possibility of powering down compute nodes when they aren’t required.
If three machines can handle the normal workload, there isn’t much reason for six machines to consume electricity just because they exist.
What I Want to Learn #
There are easier ways to build a homelab.
I could buy one modern server with a large amount of RAM, install Proxmox, and call it a day.
But that would skip much of what makes this project interesting to me.
I want to experiment with clustering.
I want to learn more about moving workloads between systems.
I want to experiment with storage.
I want to improve monitoring.
I want to see which services benefit from dedicated virtual machines and which are perfectly happy inside Docker.
I want to see how far inexpensive hardware can actually be pushed.
And I want to find useful jobs for computers that might otherwise end up sitting in a closet or becoming electronic waste.
The Current Phase: Test Everything #
Right now, I’m still at the beginning.
Before designing the final cluster, I need to inventory and test the hardware.
That means checking things like:
- CPU model
- RAM capacity
- Storage
- BIOS versions
- Network adapters
- Power consumption
- Temperatures
- Stability
- Upgrade options
Some systems will probably receive additional RAM.
Some may receive inexpensive CPU upgrades.
A few may turn out not to be worth using at all.
Once I know exactly what I’m working with, I can begin assigning roles and building the Proxmox cluster.
From there, I’ll start deploying the Ubuntu Server VMs and Docker workloads that will actually turn this collection of old PCs into a functioning homelab.
A Cluster Built from What I Already Have #
There is something appealing about building infrastructure this way.
This isn’t a lab assembled from a shopping list of ideal hardware.
It’s being built around hardware I already own, hardware I found cheaply, and machines that other people no longer had a use for.
Four Lenovo Tiny PCs.
An HP business desktop.
An X99 Xeon system.
Two old laptops.
An LGA 1155 desktop.
Individually, none of them are especially remarkable.
Together, they might become a surprisingly capable little cluster.
Finding out exactly what I can build with them is the point of the project.
This is the beginning of my mini-lab build. I’ll update Hallumina with the hardware specifications, upgrades, power consumption, Proxmox configuration, and eventual workloads as I test and deploy each machine.