We Moved Our Render Nodes to the Kitchen. Here's How We Manage Them Without a Monitor with a Phone from around the World...
I'm going to tell you something that most architectural visualization studios won't admit publicly: the backend is a mess.
Not the renders. Not the lighting setups or the material libraries. Those get all the attention, all the YouTube tutorials, all the conference talks. I'm talking about everything around the render. The infrastructure. The machines. The daily operational reality of running multiple headless render nodes in a room that nobody wants to walk into at 11pm on a Friday because something crashed.
At Diorama.Studio, we're a 4-partner operation based in Greece. We do architectural visualization and design/construction work. We're small. And because we're small, every hour spent babysitting hardware is an hour notspent on the creative work that actually pays the bills.
So we decided to fix it. Properly.
The Problem Nobody Talks About
Here's the dirty secret of small render farms: they're usually managed by whoever happens to be in the office. Someone walks over. Checks if the machine is on. Maybe restarts it. Checks again. Walks back. Opens a remote desktop session. Realizes something crashed. Restarts again.
There's no dashboard. There's no log. There's no way to know what happened at 3am when a render failed and nobody was around to see it. You find out the next morning when the deadline hasn't moved and the client is already emailing.
We had four render nodes and two workstations. All headless — no monitors, no keyboards, no mice. Just boxes doing their job in a room. Physically disconnected from everything except power and Ethernet. The only way to know if they were alive was to walk over or try to remote in and hope for the best.
That's not a system. That's a prayer.
What We Built
Today, our entire render farm is managed from a single Notion dashboard. Every machine has a row. Every row has a status. And every status updates itself.
From that dashboard — on a laptop, on a tablet, on a phone while sitting in traffic on Kifissias Avenue — any partner can:
Wake up a powered-off render node
Shut it down gracefully when it's done
Restart an unresponsive machine
Check its health — CPU load, running services, software versions, last boot time
One tap. One property change in a Notion database. The system takes it from there.
The action executes, the result comes back, the dashboard updates, and the action field resets itself so the next person doesn't have to clean up after you. The whole cycle takes 30 to 90 seconds depending on what you asked for.
No terminal. No technical knowledge required. No "ask Dimitris, he knows the IP." Just Notion.
The Network: Tailscale Mesh
One of the earliest decisions we made — and probably the most important one — was how these machines would talk to each other.
We use Tailscale as our mesh VPN. Every machine in the studio — render nodes, workstations, the Mac Mini, even our cloud server running n8n — lives on the same secure Tailscale network. It doesn't matter if a machine is in the office, in the kitchen (yes, that's where our render nodes physically sit now), or accessed from a partner's home. They're all reachable, securely, as if they were sitting on the same desk.
This is what makes the whole system possible. When n8n needs to send a command to a render node, it doesn't need port forwarding, static public IPs, or complex firewall rules. Tailscale handles the routing. Clean, encrypted, zero-config once it's set up.
And because Tailscale has mobile apps, any partner can access any machine from anywhere. Sitting at a café and need to check if Render Node 2 is alive? Open the Notion dashboard on your phone. Need full GUI access? Connect via Remote Desktop through Tailscale from your iPad. The studio follows you.
The Brain: A Mac Mini M4 Running 24/7
At the center of all of this sits a Mac Mini M4. It never sleeps. It's our operations hub — the bridge between the cloud automation layer and the physical machines on our local network.
When you tell the dashboard to wake a machine, the Mac Mini is the one that sends the Wake-on-LAN packet across the network to power it on. When you ask for a shutdown or restart, commands flow through the Mac Mini to the target machine. When you request a health check, it's the Mac Mini running the diagnostics and reporting back to Notion.
It's a small, silent, low-power machine doing an enormous amount of work that used to require a human being physically present in the room.
What Gets Monitored: Pulse RenderFlow, LucidLink & More
Here's where it gets interesting. We didn't just build a remote power button. We built a system that actually understands what matters for a render farm.
Every health check doesn't just ping a machine — it verifies the things that actually affect your renders:
Pulze RenderFlow — our render management and distribution tool. The system confirms that RenderFlow is running and that the node is registered as a render slave, ready to pick up jobs. If RenderFlow isn't running, the dashboard shows it immediately. You know before you submit a job that something needs attention.
LucidLink — our cloud-native file system that gives every machine instant access to project files. If LucidLink isn't mounted and running, a render node is essentially blind — it can't see the scene files. The health check catches this.
CPU usage — so you can see at a glance if a node is idle (ready for work), under load (rendering), or maxed out (potential problem).
Software versions — because nothing ruins a Friday like discovering one node is running an outdated version of your renderer and producing inconsistent output.
Last boot time — so you know how long a machine has been running and whether that last restart you triggered actually went through.
All of this data flows back into Notion automatically. When a machine is shut down, the dashboard doesn't just show "Offline" — it automatically marks RenderFlow and LucidLink as stopped too. No stale data. No guessing.
Automatic Health Monitoring
Every 15 minutes, an automated health check runs across every single node. No human trigger required.
It pings each machine on the Tailscale network, checks what's running, grabs CPU usage, verifies that RenderFlow and LucidLink are active, and writes everything back to the dashboard. Automatically.
This means that when you open the Notion dashboard at 8am with your coffee, you're not looking at yesterday's data. You're looking at what happened 15 minutes ago. You know which machines are online. You know which ones dropped. You know if RenderFlow crashed on Node 2 at 4am. You know if LucidLink disconnected. You know all of this before you even start your first render job of the day.
That's the difference between monitoring and hoping.
The Stack
I want to be transparent about the tools because I believe the archviz community needs more conversations about operations, not fewer:
Notion — our dashboard and single source of truth for every machine's status, actions, and history
N8N — our self-hosted automation engine that handles every workflow, every command dispatch, every status update
Tailscale — the mesh VPN that connects everything securely, from studio to cloud to mobile
Pulze RenderFlow — render job distribution and management across all nodes
LucidLink — cloud-native file system giving every machine instant access to project files
Apple Mac Mini M4 — the always-on local bridge between cloud automations and physical hardware
Anthropic Claude Code — our AI development partner that helped us architect and build the entire system
No enterprise monitoring software. No vendor lock-in. No monthly per-node licensing fees that make you question your life choices. Just open-source and self-hosted tools connected with intention.
Why Claude Code Changed the Game
I want to talk about this specifically because it was genuinely transformative for us.
We're architects and artists. We understand systems thinking — we design buildings, we think about flows and structures all day. But implementing backend infrastructure? Writing the logic that handles retries when a machine doesn't respond on the first wake-up attempt? Designing the error handling for every edge case across six different sub-workflows?
That's where Claude Code came in. Not as a magic button that writes code for you, but as a development partner that understands your architecture and can help you think through problems faster than you could alone.
We used it to go from concept to working system in a fraction of the time. The iteration speed was incredible — describe what you need, review the approach, refine, deploy. For a three-person studio without a dedicated developer, this is not a nice-to-have. It's the difference between building the system and never getting around to it.
What We Learned
1. Operations is a creative problem. Designing how your studio runs is no different from designing a building. It requires understanding flows, anticipating failures, and creating systems that serve the people using them. If you approach it with the same care you bring to your renders, the results are extraordinary.
2. Self-hosted means self-reliant. When your automation server is yours, your data is yours, and your logic is yours, you're not at the mercy of a SaaS company's pricing changes or feature deprecations. Yes, it takes more effort upfront. But the long-term payoff in control and flexibility is worth every late night.
3. Monitor what matters, not what's easy. Knowing a machine is "online" is useless if LucidLink isn't mounted or RenderFlow isn't registered. The system checks what actually affects your output — and that's the difference between a monitoring tool and a real operations platform.
4. The best interface is the one your team already uses. We didn't build a custom web app. We didn't create a mobile app. We put everything in Notion because that's where our team already lives. The fastest path to adoption is zero friction.
5. Small studios can have enterprise-grade operations. You don't need 50 employees and a DevOps team to run a smart infrastructure. You need clear thinking, the right tools, and the willingness to treat your operations with the same respect you give your creative output.
What's Next
This render farm management system is one piece of a larger vision. We're building out construction site operations tracking, automated invoice processing, and a unified contacts system — all following the same philosophy: Notion as the interface, n8n as the engine, Tailscale as the network fabric, and AI as the development accelerator.
We'll keep sharing what we learn. The AEC industry is full of talented artists working with incredible tools to produce beautiful projects.
