Skip to content

My Home Server / Home Lab Build Plan

Recently, I started planning a Home Server / Home Lab of my own.

The goal is not simply to “put a server at home.” I want to build an environment that I can use for the long term, expand gradually, and use to gain hands-on experience with Networking, Linux, Virtualization, Containers, Cybersecurity, Cloud, and DevOps.

In the future, this system will not only be used for file storage and home network management. I also want it to host my own development projects, including MarketLens, databases, APIs, Docker services, and various self-hosted development and monitoring tools.

This article documents my current design direction. The Home Lab will be built in phases, so the final hardware and software configuration may change as I test different ideas and refine my requirements.


I want this system to have the following characteristics:

  • Secure: Important services should not be exposed directly to the public Internet.
  • Scalable: I should be able to add more servers, NAS storage, VMs, containers, and other services later.
  • Educational: Instead of only buying a ready-made NAS, I want to configure Networking, Firewall, VLANs, VPN, Linux, and Servers myself.
  • Maintainable: Different responsibilities should be separated as much as possible, making troubleshooting and future upgrades easier.
  • Low power consumption: Because the system may run 24/7, power usage and cooling need to be considered.
  • Practical: The lab should not only be for learning, but should also provide real services for my home network and software projects.

My current high-level design looks roughly like this:

flowchart TD
Internet((Internet))
ONT[ISP ONT]
FW[OPNsense Firewall<br/>N150 Mini PC]
SW[Managed Switch]
WIFI[Wi-Fi Access Points]
NAS[NAS / Storage Server]
SERVER[Home Server]
CLIENTS[PC / Laptop / Mobile]
IOT[IoT Devices]
GUEST[Guest / Airbnb Wi-Fi]
VM[Virtual Machines]
DOCKER[Docker Containers]
ML[MarketLens]
DB[(Database)]
MON[Monitoring / Dev Tools]
TS[Tailscale<br/>Remote Access]
Internet --> ONT
ONT --> FW
FW --> SW
SW --> WIFI
SW --> NAS
SW --> SERVER
SW --> CLIENTS
WIFI --> IOT
WIFI --> GUEST
SERVER --> VM
SERVER --> DOCKER
DOCKER --> ML
DOCKER --> DB
DOCKER --> MON
TS -. Secure Remote Access .-> FW

In this design, the OPNsense Firewall sits between the Internet and the internal network and acts as the main gateway for the entire Home Lab.

Behind it are the Managed Switch, Wi-Fi Access Points, NAS, Home Server, and the different types of devices used around the home.


I have already prepared an Intel N150 Mini PC to use as a dedicated firewall.

I plan to install:

OPNsense

Its main responsibilities will include:

  • Firewall Rules
  • NAT
  • DHCP
  • DNS
  • VLAN Routing
  • Network Segmentation
  • VPN / Remote Access
  • Traffic Monitoring

I want to keep the Firewall separate from the Home Server.

In other words, even if I later need to reinstall the Home Server, NAS, or Docker environment, the household network itself should continue working normally.

This also makes the overall architecture more similar to the way business or enterprise networks are designed.


A Managed Switch will sit behind OPNsense.

Compared with a normal Unmanaged Switch, a Managed Switch lets me create VLANs and separate different types of devices.

For example:

VLANPurpose
ManagementFirewall, Switch, and Access Point management
HomePersonal computers, laptops, and phones
ServerNAS, Home Server, and Databases
IoTSmart TV, IoT, and smart-home devices
GuestAirbnb / guest Wi-Fi
LabTest VMs, Security Lab, and Experimental Services

The biggest advantage is that I can control what each network is allowed to access.

For example:

Guest Wi-Fi
↓
Internet
✓
Guest Wi-Fi
↓
NAS / Home Server
✗

Even if a Guest or IoT device has a security issue, it should not be able to directly access my servers or private files.


The Home Server will be the main compute platform for the Lab.

At the moment, I expect it to handle:

  • Virtual Machines
  • Docker Containers
  • Development Environment
  • Database
  • Self-hosted Services
  • Monitoring
  • CI/CD Experiments
  • AI / Automation Experiments

One important area is Virtualization.

In the future, I may run something like:

Home Server
│
├── Linux VM
├── Windows VM
├── Docker VM
├── Development VM
├── Security Lab VM
└── Testing VM

This keeps different workloads isolated from each other.

If I break one lab environment, I can simply delete the VM or restore a snapshot without affecting the entire server.


Docker will be a major part of this Home Lab.

Many services can run as containers, for example:

Docker
│
├── MarketLens
├── PostgreSQL
├── Redis
├── Reverse Proxy
├── Monitoring
├── Dashboard
├── Git-related Services
└── Experimental Applications

The main advantage of containers is that environments are easier to rebuild, and it becomes much easier to separate Development, Testing, and Production-like environments.

For software development, this will also be a useful experimentation platform.


One practical use case is running my own stock-analysis project, MarketLens.

In the future, MarketLens may be separated into several components:

MarketLens
│
├── Data Downloader
├── Data Processing
├── Screener
├── Backtesting
├── API
├── Web Application
└── Database

For example, historical market data could be stored on the Home Server or NAS, while the analysis processes run on the server.

Over time, I also want to experiment with:

  • Scheduled Jobs
  • Background Workers
  • API Services
  • PostgreSQL
  • Redis
  • Docker Compose
  • Monitoring
  • CI/CD

This means the Home Lab will not only be a learning environment; it will also host a real software project.


The NAS will mainly be responsible for storage rather than putting every workload on the Home Server.

For example:

NAS
│
├── Documents
├── Photos
├── Backups
├── Development Backups
├── Market Data
├── VM Backups
└── Media

I want to separate:

Compute

from

Storage

as much as possible.

In other words:

Home Server = Compute
NAS = Storage

This means that if I later upgrade or reinstall one machine, the impact on the other part of the environment should be reduced.


Another feature I plan to add is Tailscale.

Tailscale can create a secure private network between my laptop, mobile phone, and Home Lab.

Conceptually:

Laptop / Phone
│
│ Internet
│
▼
Tailscale
│
▼
OPNsense
│
├── Home Server
├── NAS
└── Internal Services

This means I can securely access my Home Lab even when I am away from home.

Most importantly, I want to avoid exposing services such as these directly to the Internet:

SSH
RDP
SMB
Database
Proxmox / Hypervisor UI
NAS Admin UI

Remote access should go through a secure VPN / Private Network rather than relying on simple Port Forwarding.


My eventual network may look something like this:

Internet
│
▼
OPNsense
│
▼
Managed Switch
│
├── Management VLAN
│
├── Home VLAN
│
├── Server VLAN
│
├── IoT VLAN
│
├── Guest VLAN
│
└── Lab VLAN

Firewall Rules can then control traffic such as:

Home → Server
Allow selected services
Server → Internet
Allow when required
Guest → Internet
Allow
Guest → Home / Server
Block
IoT → Internet
Restricted
IoT → Server
Block by default

I want to follow a design philosophy closer to:

Default Deny + Explicit Allow

In other words, different networks should be assumed to have no access to each other by default, and only the required traffic should be opened.


For me, the greatest value of a Home Lab is not simply “owning a server.”

The real value is having the opportunity to work with a complete IT infrastructure myself.

For example:

Networking
↓
Firewall
↓
Linux
↓
Virtualization
↓
Docker
↓
Database
↓
Web Services
↓
Monitoring
↓
Security
↓
Automation
↓
Cloud / DevOps

It is easy to feel that you understand something after watching a tutorial.

But once you build the system yourself, you start running into real problems such as:

  • DNS issues
  • Routing issues
  • Firewall Rules
  • Permissions
  • Certificates
  • Storage
  • Backup
  • Networking
  • Deployment
  • Monitoring
  • Security

Those practical problems are exactly what make building a Home Lab so valuable.


For now, I plan to divide the project into several phases.

First, build the basic home network:

Internet
→ OPNsense
→ Managed Switch
→ Wi-Fi / Clients

The main focus will be:

  • OPNsense
  • DHCP
  • DNS
  • Firewall
  • VLAN
  • Guest Network

Add the main server:

OPNsense
│
Managed Switch
│
Home Server

Start learning and working with:

  • Linux
  • Virtualization
  • VM
  • Docker
  • Server Management

Add storage:

Home Server
│
└── NAS

Set up:

  • File Storage
  • Backup
  • VM Backup
  • Development Backup
  • Market Data Storage

Add:

Tailscale

so I can securely access the following when I am away from home:

  • Home Server
  • NAS
  • SSH
  • Development Services
  • Monitoring Dashboard

Begin deploying real applications:

MarketLens
Database
Docker Services
Monitoring
Dashboards
Development Tools

Later, gradually add:

  • Kubernetes
  • CI/CD
  • Infrastructure as Code
  • Security Monitoring
  • Central Logging
  • Reverse Proxy
  • Internal DNS
  • Certificates
  • AI Services
  • Local LLM Experiments

This will be a long-term learning project rather than something I try to finish all at once.


Ultimately, I want the Home Lab to become a small private IT infrastructure:

Internet
│
▼
OPNsense Firewall
│
▼
Managed Switch
│
┌───────────┼───────────┐
│ │ │
NAS Home Server Wi-Fi
│
┌─────┴─────┐
│ │
VMs Docker
│
┌──────┼──────┐
│ │ │
MarketLens DB Services

It can function as:

  • Home Network Infrastructure
  • NAS
  • Development Server
  • Private Cloud
  • Cybersecurity Lab
  • DevOps Lab
  • AI Experiment Platform

It will also let me connect what I am learning about Software Development, Networking, Cloud, and Cybersecurity into one practical environment.


Next, I plan to document the build process step by step, including:

  • OPNsense installation
  • Firewall configuration
  • VLAN design
  • Managed Switch configuration
  • Wi-Fi network segmentation
  • Home Server hardware
  • Virtualization
  • Docker
  • NAS
  • Tailscale
  • MarketLens deployment
  • Monitoring
  • Backup strategy

I hope this series can become more than just my own technical notes and may also help others who want to start building a Home Lab.

Home Lab Build — To be continued.