My Network Used to Look Like This: Revisiting a Homelab Diagram

Every homelab has a moment in its history that looks perfect on paper.

Multiple servers humming along on high-speed networking, carefully planned infrastructure, everything connected exactly the way it should be. It's the kind of setup you proudly turn into a diagram and share with other enthusiasts.

That's exactly what happened when one user shared an old network diagram they built using ExcaliDraw. The diagram was created a couple of years ago for a class assignment, back when their infrastructure was far more elaborate than it is today.

Since then, life happened. Hardware got sold, equipment failed, and the network evolved, so what was once a carefully designed homelab slowly turned into something smaller and more practical. The diagram still exists, though, and it tells a story that many homelab builders recognize immediately.

When a diagram becomes a snapshot of a moment

Network diagrams have a strange quality: they freeze infrastructure in time.

The diagram shared in this discussion was built during a period when the user had access to much more powerful hardware. Their environment included enterprise equipment like HP DL380 Gen9 servers and 10-gigabit Mellanox networking gear, which is serious hardware for a homelab.

Maintaining setups like that can be expensive, though. Power consumption adds up, replacement parts cost money, and sometimes the equipment simply fails.

In this case, the user explained that one of the servers had to be sold, along with the Mellanox 10-gig networking cards and receivers. The distribution switch eventually died as well; it had already been a hand-me-down nearing the end of its life. Suddenly the once-complex network looked very different, and the diagram remained as a reminder of what the setup used to be.

Why people still love drawing their infrastructure

Even with automated infrastructure tools everywhere, people still draw diagrams, and for good reason. Diagrams turn abstract systems into something visible. Instead of holding dozens of connections in your head, you see the entire architecture laid out in front of you.

That's especially helpful in homelabs, where people experiment constantly. Containers move between nodes, firewalls change, and storage pools expand. A good diagram helps you remember what connects to what, and sometimes it helps explain your setup to other people who are curious about how everything works.

That curiosity showed up quickly in the discussion. Several people asked how the diagram was created, assuming it required programming knowledge or specialized tools. The answer was surprisingly simple.

The tool behind the diagram: ExcaliDraw

The diagrams were created using ExcaliDraw, a collaborative drawing tool known for its hand-drawn style.

Compared to traditional diagram tools like Visio or Draw.io, ExcaliDraw feels intentionally loose. Lines look sketchy and shapes aren't perfectly rigid, so the result resembles something drawn on a whiteboard rather than a corporate presentation slide.

That informal style makes it popular among developers and system administrators. You can sketch ideas quickly without worrying about perfect alignment or strict formatting, and for many people that freedom makes it easier to brainstorm complex systems.

The author mentioned that they were using ExcaliDraw long before the recent surge of AI tools and coding assistants; it was simply their preferred way to map out infrastructure ideas. Interestingly, the diagrams were originally built using JSX-style components, blending coding concepts with visual design. That approach isn't common, but it reflects how many developers think about systems today, as combinations of components connected by flows.

Learning infrastructure the hard way

Another interesting part of the conversation was how the diagram came to exist in the first place. It started as a security class assignment instead of a production homelab or a work project.

The diagrams illustrated communication flows between systems, such as senders, receivers, encryption, and digital signatures. Those flows could represent email delivery, encrypted messaging, or other secure communication processes. So the diagrams were less about hardware and more about understanding how secure data travels between systems.

That academic project turned into something larger. The student received an A for the assignment, and the diagrams became a foundation for learning more about networking and infrastructure design.

For many people in the homelab community, that path feels familiar: a class project becomes a hobby, and eventually the hobby turns into real infrastructure.

The messy side of building diagrams

While the diagrams looked impressive, the creator admitted the process wasn't exactly smooth. Spacing elements in complex diagrams can be surprisingly difficult, and once a network diagram grows beyond a few nodes, everything gets harder to organize. Components overlap, lines cross awkwardly, and sections of the architecture start crowding each other.

The user joked that the "React zones" in the diagram had become messy while trying to reorganize everything. Anyone who has built large diagrams knows this frustration well. You start with a clean layout, then you add another server and another network segment, and before long the diagram resembles a plate of spaghetti. Still, those imperfections are part of the process.

From diagrams to real infrastructure

The discussion eventually shifted toward what the user is running today. One commenter suspected that a setup like this probably involved containers or Docker-based workloads, and they were right.

The author revealed that they currently run a four-node Portainer cluster, which manages containerized services across multiple machines. That's a far cry from a simple single-server homelab.

Even though the original hardware has changed, the spirit of experimentation is the same. Containers, clusters, and networking flows, all the elements that appeared in the diagrams, still exist in the actual infrastructure. The diagram simply captured an earlier stage of that journey.

Why old diagrams still matter

It's easy to dismiss old infrastructure diagrams once the hardware changes, but they often reveal how someone learned to think about systems.

Every homelab evolves. Servers get replaced, networks shrink or grow, and technology changes quickly. The lessons learned while designing those diagrams stay with you, though. Understanding how data flows through a system, how firewalls interact with containers and how encryption works between sender and receiver, builds a mental model that carries forward into future projects.

That's why many engineers keep their old diagrams around. Beyond documentation, they're a record of how their understanding of systems evolved.

The pride behind a homelab

If one emotion runs through conversations like this, it's a low-key kind of pride, a long way from polished tech marketing videos: the pride of someone who built something imperfect, experimental, and constantly evolving by themselves.

The user who shared the diagram even admitted they were still learning, especially when it comes to frontend tools like React. Networking and containers were their strengths, but visualizing everything in code was a challenge, and they kept working through it anyway.

That's the story behind most homelabs: they're ongoing experiments that never quite sit still.