Everything Wants a Second Life

Nothing has only one use until you decide it does.

If I Can't See It, I Don't Understand It

Nothing has only one use until you decide it does.

If I Have to Do It Twice, I Build a System

Nothing has only one use until you decide it does.

Think Inside the Box

Nothing has only one use until you decide it does.

Embrace the Mistake

Nothing has only one use until you decide it does.

Tuesday, October 20, 2026

Less Control, More Intelligence: Why I Switched to a Deco Mesh.

Homelab · Networking

This post contains an affiliate link. As an Amazon Associate, I earn from qualifying purchases, at no extra cost to you.

I made a switch that, at first, I didn't think was necessary.

For several months, I had been running my own custom Wi-Fi setup using three different access points. It worked, and in many ways, I liked having that level of control. But over time, I started running into problems that became increasingly difficult to ignore.

The biggest issue was how certain devices handled the split between my 2.4 GHz and 5 GHz networks. I also had one access point that caused a broadcast storm, a problem so severe that it could bring down the entire network.

That was the point where I started reconsidering my setup.

While I was figuring out what to do, I temporarily replaced the problematic access point in my office with a simple TP-Link range extender plugged directly into a wall outlet. It wasn't an elegant solution, but it kept things working while I waited for the replacement.

Eventually, I decided to go with something specifically designed to handle this problem: a TP-Link Deco X15 (AX1500) mesh system, with all three units wired back to the network over Ethernet.

And it works extremely well.

The three TP-Link Deco X15 units installed around the property
The three Deco X15 units, each one wired back to the network.

The setup

Wi-Fi: TP-Link Deco X15 (AX1500), 3 units, Access Point mode, wired backhaul

Firewall / DHCP: OPNsense

DNS filtering: Pi-hole

Coverage: roughly 1,200 m², fully cabled property

Less control, more intelligence

The biggest difference is that I gave up some of the independence I had with my previous setup.

Previously, I could separate devices based on the network they connected to. I had a 2.4 GHz network and a 5 GHz network, each with its own name, and I decided which devices belonged to each one. Some devices connected exclusively to 5 GHz, while others were limited to 2.4 GHz.

The Deco system takes a different approach.

Instead of exposing those bands as separate networks, it makes that decision for you. Every device connects to the same network name, and the system determines which band makes the most sense based on the device and what it currently needs.

Normally, I'm not a huge fan of giving up that kind of control.

But in this case, it works.

Across my roughly 1,200-square-meter property, I have essentially the same coverage and availability I had before. My services continue to work on the devices that need them. What I no longer have is the ability to split devices across separate Wi-Fi networks.

That's the biggest compromise I've made.

And surprisingly, it's not a dealbreaker.

The setup was almost too easy

The actual installation was incredibly simple, with one catch.

I placed the units, wired them in, switched the system to Access Point mode, and used the same network name and password as my old main network.

Deco app showing the mesh topology with all nodes on Ethernet backhaul Deco app node list with an abnormal WAN port speed warning

One network name, all three units on Ethernet backhaul. The app also flagged my next bottleneck: an old 100 Mbps switch.

Most of my devices simply reconnected.

The exceptions were the few devices set to use my old 5 GHz-only network, which no longer existed. One of them was my headless media server: a laptop with a cracked screen that I manage over SSH. When its network disappeared, it went offline, and I had no screen to fix it from. I ended up connecting a monitor and keyboard, and while I was at it, I moved it to a permanent wired connection through a USB Ethernet adapter.

Lesson learned — anything headless should never depend on Wi-Fi.

There was a second, sneakier side effect. Modern phones use a randomized MAC address for each Wi-Fi network they join. When the network changed, some phones showed up as brand-new devices and quietly slipped out of the IP reservations and Pi-hole filtering groups I had set up for them.

Heads up — if you rely on MAC-based rules, check them after any Wi-Fi change.

After that?

Everything just worked.

And that's the part I appreciate the most.

What I lost

The downside is that I lost some flexibility.

With my previous setup, I could decide exactly which network each device joined. The Deco system isn't really designed around that philosophy. It's built to make the network work automatically.

It also comes with a catch I didn't love: there's no web-based setup. Configuration has to be done through TP-Link's mobile app, and that requires a TP-Link account. For someone who prefers self-hosted, local-only tools, that's a real drawback.

For someone who wants maximum control over their Wi-Fi, these might be significant disadvantages.

For me, the tradeoff is reasonable, mostly because of how I set it up.

Where the control actually lives

I'm running the Deco system in Access Point mode, behind my OPNsense firewall and Pi-hole.

That means the Deco only does one job: Wi-Fi. It doesn't hand out IP addresses, it doesn't filter anything, and it doesn't make routing decisions. My firewall still assigns every address, my DHCP reservations still apply, and Pi-hole still filters DNS for every device on the network.

OPNsense Dnsmasq leases showing the three Deco units with reserved IP addresses
The Deco units get their addresses from OPNsense, like any other device on my network.
The control I gave up is control over the radios, not over the network itself.

And I still have a plan for segmentation

I'm not completely giving up on network separation, either.

One limitation I ran into is that the Deco, in Access Point mode, can't tag separate Wi-Fi networks onto separate VLANs. So true isolation has to happen somewhere else.

My plan is to repurpose one of my older access points as a completely separate guest network, connected to its own port on the firewall. Visitors get internet access and nothing else.

My security cameras are wired, so they don't need a separate access point at all. They'll stay on the main network, but the firewall will block them from reaching the internet.

Smart TVs and similar devices get a different treatment: Pi-hole blocks their telemetry, and the firewall forces all their DNS traffic through it, so devices with hardcoded DNS servers can't sneak around it.

That gives me an interesting combination: the Deco system handles the household Wi-Fi, while the firewall and an older access point handle everything that needs to stay apart.

What it cost

One more thing worth saying: this upgrade didn't break the bank.

~$130

Total spent · Deco X15 three-pack

The only thing I bought was the Deco X15 three-pack, for about $130. Everything else, from the firewall and Pi-hole to the cabling and the older access points, was infrastructure I already had.

For the stability I got in return, it's one of the best-value changes I've made to my network.

Affiliate link. As an Amazon Associate, I earn from qualifying purchases.

So, was the switch worth it?

Absolutely.

I went from a setup that gave me more control but occasionally created problems, to one that gives me slightly less control but is considerably more stable and smarter about how it manages Wi-Fi.

And sometimes, that's the better choice.

I've spent a lot of time building systems where I control every little detail. But there's also something to be said for installing something, turning it on, and having it simply do its job.

In this case, I'm willing to give up a little independence in exchange for a network I don't have to constantly think about.

And that might be the biggest upgrade of all.

Friday, September 11, 2026

From a Broken Laptop to a Server

I live on a very small Caribbean island, so there isn't much of a market for used technology. Most of my opportunities come from Facebook Marketplace, and because the population is small, good deals don't show up very often.

So when I saw someone selling two relatively new HP laptops with broken screens, I stopped to look.

It was a little strange. Screens don't usually just break from normal wear and tear, and I had no idea what had happened to them. My best guess: someone kept stacking heavy things on top of them. But honestly, that didn't matter much to me.

Broken HP laptop screen, shattered display pattern

They were relatively new models — an HP G8 and an HP G9, one with an Intel processor and the other with AMD. I started doing the math in my head.

Maybe $50 for a laptop. Another $50 for a replacement screen. I could do the repair myself, and I'd have a perfectly useful laptop for using in bed at night without having to turn on my main computer.

I offered $100 for both. We eventually settled on just one.

Then I checked the specifications more carefully. The screen resolution was pretty basic, and once I couldn't find the replacement screen I wanted — at the resolution I actually cared about — I started thinking about it differently. I didn't actually need another laptop collecting dust.

What I needed was another server.

So instead of replacing the screen, I turned it into a headless machine.

Broken laptop connected to external monitor during setup

Why move multimedia off my main machine in the first place

Running a home server has given me a lot of freedom, and I've learned a huge amount along the way. But one thing became obvious pretty quickly: different services need different things, and lumping everything onto one machine isn't always the smart move.

My multimedia services — music and video streaming — were originally running on my main desktop, IMPERFECT. It made sense at first: powerful CPU, plenty of RAM, no problem handling the load. But that was exactly the issue. I was keeping a full desktop running around the clock just so a movie or a song would be available if someone wanted one. Power consumption aside, it was also just annoying — if I wanted to watch something, I had to go turn the computer on first.

That's backwards. A media server should be the thing that's always on, quietly waiting. The desktop should be the thing I turn on when I actually need to do something with it, not the thing I have to boot just to press play.

So the broken laptop solved two problems at once: it gave the multimedia stack a dedicated, low-power home, and it freed my main desktop from having to stay on 24/7 for services that don't need that kind of horsepower anyway.

The technical rundown, for anyone who wants it

If you're the type who wants the actual stack instead of just the story, here's what's running — and it's more than I expected to end up with when I started:

  • OS: Ubuntu Server 26.04 LTS, no desktop environment — just Docker and whatever it takes to keep the containers alive
  • Storage: the original NVMe drive, upgraded for more local headroom, plus network mounts to my NAS for anything that outgrows local disk

Services, all in a single Docker Compose stack:

Navidrome for music. Migrating it turned up its own small lesson — I went looking for the old instance's data, ready to carefully back up playlists and listening history before the move. The data volume turned out to be completely empty. Whatever I thought was being saved there, never actually was. Nothing to migrate, so I just started fresh.

Ubuntu Server terminal session during headless setup

Jellyfin for movies and series, split across two sources by design. Anything new — freshly downloaded, not yet watched, still "hot" — lands on the laptop's local disk first, in its own folder that Jellyfin treats as its own library. That's deliberate: local disk is fast, and I don't want new content depending on network speed or NAS availability the first time someone wants to watch it.

Once something has been watched and isn't "new" anymore, it gets moved manually over to the NAS — which is where the bulk of the actual library lives, mounted read-only inside the container. I haven't automated that move yet. I want to actually live with the manual process for a while first and see what "not new anymore" really means in practice before I write a script that decides that for me. The plan, eventually, is something that sweeps the local folder on a schedule and relocates anything older than some threshold — but I'd rather get the threshold right by observing real usage than guess at it upfront.

Either way, from Jellyfin's side, both sources just show up as one unified library. Nobody browsing has to know or care where a given movie physically lives.

qBittorrent, no VPN in front of it. That's a cost I'm not covering right now, and I'd rather say that plainly than pretend otherwise.

FileBrowser, so moving files between local storage and the NAS doesn't mean SSHing in every time just to drag one folder into another.

  • Networking: this laptop has no physical Ethernet port at all, so everything runs over WiFi. That meant setting a static IP directly on the wireless interface — and separately reserving a static IP for a USB-Ethernet adapter I sometimes plug in for maintenance, so the two never fight over the same address if I ever use both at once. Local DNS entries point clean hostnames at all of it, and it's wired into the same family dashboard as the rest of the homelab.
  • Power: no battery — I pulled it out and genuinely don't remember where it ended up. Lid-close behavior is disabled at the systemd level, since Ubuntu's default is to suspend the machine the moment the lid shuts, which is exactly backwards for something meant to run 24/7 with the lid closed for good.
  • Monitoring: wired into my existing Uptime Kuma dashboard. If any of the four services drops, I know before anyone in the house notices the music stopped.

One thing still unresolved: Wake-on-LAN. I can't confirm whether it's even enabled in the BIOS, because — you guessed it — the screen is broken, and by the time I thought to check, the lid was already shut in its final resting spot under one of my access points. For now, it just stays on. Given how little power this thing actually draws, that's a trade I'm fine making.

And because apparently I couldn't just put it on a shelf like a normal person

I tucked it underneath one of my access points and left it there, plugged in and quietly doing its job.

Laptop tucked under a WiFi access point on a shelf

I don't even remember where I put the battery.

And that's fine.

The original idea was to find a cheap laptop for myself. What I ended up with was a little server that I didn't have to buy separately.

That's one of the things I like about this whole homelab experiment: it's constantly forcing me to reconsider what something is worth.

A broken screen doesn't necessarily mean a broken computer. An old laptop doesn't necessarily need to become someone's next laptop. Sometimes the useful part of a piece of hardware is the part you weren't originally looking at.

My kids get laptops from school that I don't necessarily need. My wife isn't particularly interested in using a laptop. And I'm not going to buy technology just because I can.

But when something comes along that I can repurpose, I don't want to automatically dismiss it just because it isn't useful in the way it was originally designed.

Friday, August 28, 2026

One Game at a Time

Parenting · Gaming · Philosophy

One Game at a Time

I remember waiting an hour by the radio for one song.

Not scrolling for it. Not streaming it on demand. Just sitting there, waiting for MTV or the radio to play it, because that was the only way to hear it again.

If I saved up enough, I'd buy the CD.

And that CD was freedom.

It meant I could finally listen to the same song as many times as I wanted.

Games worked the same way.

If I saved up for one, I played everything it had. I found the hidden levels. I tried every mode, every mechanic, every way of playing it. I even attempted speedruns, back when that word barely meant anything outside a small crowd.

Scarcity made me thorough.

My son doesn't have that problem.

He has the opposite one.

Free, paid, pirated — the options are endless. When there's always another game waiting, it's easy to pick something up, play it for a while, get bored, and move on.

Nothing forces you to finish anything.

So I decided something would.

My game library isn't small; I can afford more games. It's small for him on purpose.

Giving him access to everything I own would be easy. But that's not the point.

The point isn't giving him a world of options.

It's asking him to pick one game from the world I've already narrowed down, finish it, and only then pick again.

Dante's desktop showing a curated, limited game library

The whole library. Not that much bigger than it looks.

He doesn't get a new game until the last one is done.

Whether he finishes it well, finishes it fast, or finishes it reluctantly — that's his choice.

But there is no next game until this one is closed.

And it's already paid off.

He finished Hollow Knight.

Then Silksong.

Dante's desktop wallpaper themed around Hollow Knight: Silksong

Dante's desktop — Hollow Knight: Silksong still on wallpaper duty.

He went back and fought bosses more than once, not because he had to, but because he wanted to get better at them. He started setting himself challenges nobody asked him to attempt.

That's the part I wanted.

Not that he finished two games.

That he invested enough time in something to become genuinely good at it.

That kind of time investment leaves something behind. Video games can teach this in a simple, contained way that real life usually teaches the hard way:

What you actually invest your time in gives something back.

Sometimes immediately.

Sometimes much later.

But something remains.

That's why my son plays one game at a time.

We don't always get to choose what entertains us in life. More often than we'd like, we have to do things we don't enjoy simply because they need finishing.

I want my son to learn that lesson early, somewhere the stakes are low.

A video game.

Not a job. Not a responsibility he can't walk away from. Not something where failure carries consequences that matter.

Just a game.

If he decides to finish what he starts, and whether he finishes it well or badly, that's his decision to make.

But he won't get to start something new until he does.

And that's also why freemium games aren't part of his library.

Not because they're free.

Because many of them are designed around a completely different relationship with your time. They don't simply ask you to play. They are built to monetize attention — sometimes in ways that resemble the mechanics of a casino more than those of a traditional game.

That's a different kind of hook.

And it's not one I want anywhere near him.

I don't want to teach him that the next thing is always better.

I want to teach him that sometimes, the thing you're already doing is worth staying with.

This post contains Amazon affiliate links. If you purchase through them, I may earn a small commission at no extra cost to you. Every product listed here is something I personally own and use daily.

Monday, August 24, 2026

Chasing the Cheese

Homelab · Networking · Troubleshooting

Chasing the Cheese


The first thing to do today is to chase the cheese, just as a mouse does in a maze.

After going in a circle over a solution which, at first, appeared rather simple.

I had not experienced any serious network problems for more than two months. One morning, while I was quietly having my breakfast, I noticed that the connection had gone down. I then finished my breakfast, had my coffee and went to look at the monitor.

All services were down.

Perfect.

The cheese was located somewhere in the maze.

To begin with, I believed that the internet connection had simply gone down. I looked at the admin computer and found that it wasn't connected to the network. I then restarted the OPNsense server, hoping that it was one of those issues which can be fixed by a restart and some patience.

It didn't work. At that moment I understood that the problem was likely more complicated than it appeared.

There is an emergency procedure specifically for cases like this. I carried out the bypass and, for now, kept the admin computer connected directly to the ISP. The concept was straightforward: ensure that at least the basic functions continued while I worked on discovering what was going on with the main network.

It took about five or six minutes for the bypass to stabilise, but even then the connection was still not behaving properly. There's where the labyrinth started.

Wrong Turn One

The First Problem.

To begin troubleshooting I connected directly to the server.

First mistake.

When I needed to be working on the LAN, I plugged the cable into the WAN port since I was looking for a DHCP problem and so I began to check what was going on in OPNsense.

The console began to provide me with clues, even though none of them appeared to point directly to the issue.

DHCP was down.

When I checked the processes, I didn't see either dhcpd or kea-dhcp4 running; the only one there was the WAN DHCP client.

I used some commands that I had remembered from earlier installations of pfSense.

clog.

It didn't exist.

I attempted the command service dhcpd onestart.

Nothing.

Then service kea-dhcp4 onestart.

Nothing.

Finally, service kea onestart.

The system began Kea.

However, the process stopped right away.

By that stage I began to consider the possibility that I was encountering a known bug in the version of OPNsense that I was using, one that might have something to do with a socket or with a previous process which had become blocked.

I was searching for a solution on the server.

The problem did not lie there.

The Turning Point

The Piece of Information That Changed Everything.

I attempted to log in using SSH.

Timeout.

Not a connection rejection.

A timeout.

I then looked at the network configuration from a different machine and found something interesting: my Wi-Fi was on a different subnet, namely 192.168.1.x, since it was connected directly to the ISP's router through the bypass.

But then I asked a much more basic question:

Did ping ever work?

The answer was no.

Not even directly connected.

The fact about that matter completely altered the diagnosis.

I looked at the server's physical interfaces.

ifconfig igb0

And there it was:

status: no carrier.

There was never any physical connection.

I was just as puzzled by wg0, but it was a virtual interface and had no connection with the physical port.

So I checked igb1.

Here was the problem.

The cable was plugged into the incorrect physical port on the dual NIC.

I repositioned the cable to igb0.

The interface became active.

Ping.

Working.

I reconnected the WAN and checked the connection using 10 out of 10 packets with 8.8.8.8.

Problem solved.

Or so I thought.

The cheese was still dripping.

Wrong Turn Two

The Second Problem.

The network was restored.

It then began to drop every ten or fifteen minutes.

The switch would freeze, and the only fix was to turn it off and then on again.

Once.

Twice.

Three times.

Always the same.

The switch in question was a Linksys SE3008v2, a simple unmanaged switch. It had no interface available, no logs that could be examined, and no straightforward method of finding out what it was doing.

Therefore I began to look at the topology.

I had two switches.

The first held the connected critical infrastructure — OPNsense, the NUC, the NAS, and other equipment.

The second held the office computer and several access points.

You can see a map of the full network layout in this earlier post.

The first idea was simple: what would happen if I take out the first switch?

I could simplify the network temporarily and carry on with just one switch until I received a replacement.

However, there was a problem.

I couldn't remove OPNsense.

I then had to discover what was causing the switch to overload.

Then I saw it.

The lights on the switch were flashing rapidly.

All of them.

This wasn't normal traffic. It seemed as if a tiny green disco had been set up in my office.

All the evidence indicated that there was a broadcast storm.

The Hunt

Isolate the Problem.

I cut the uplink that connected Switch 1 to Switch 2.

Switch 1 settled down immediately.

The loop lived downstream. Now I needed to find exactly where.

I disconnected everything from Switch 2. Only the uplink stayed in place.

Sixty seconds. Nothing.

Ninety seconds. Still nothing.

Switch 2 itself wasn't the problem.

One by one, I started bringing devices back online.

Archer first. Twenty minutes. Clean. It was even serving internet on its own.

Then Linksys02101.

Within minutes, the uplink and Archer's port both lit up — frantic, sustained, the same green disco from before.

Linksys itself stayed almost calm.

I disconnected it.

The storm stopped in seconds.

The cause had a name now: Linksys02101.

I checked its configuration, expecting to find Wireless Bridge mode — the classic mistake, an access point talking to another one over the air while it's still wired into the same switch. Two paths. One loop.

It wasn't that.

Plain Bridge Mode. Correctly set. Exactly as it should have been.

I never found out why.

The Fix

The Solution.

Getting the Linksys off the shared network was the goal — not necessarily figuring out what was actually wrong inside it. I set it up in full router mode: its own subnet, its own DHCP running locally instead of trusting OPNsense's, a unique SSID separate from the shared mesh name, hung off the Tenda instead of the main switch. With NAT in between, it wouldn't matter what mechanism had been causing the loop — there'd be no path left for it to travel back into the rest of the network.

It froze mid-configuration. Not later, not under load — while I was still setting it up.

That settled it. Whatever was actually wrong with that router, reconfiguring around it wasn't going to fix it. It came out of service entirely, replaced for now with a simple wireless range extender — no Ethernet port at all, nothing for it to loop through even if it tried. A real mesh system is already planned for October. Until then, this holds.

The Point

A whole day, and I still don't know why.

Problems like this eat the whole day. Not almost — the whole day; this one didn't wrap up until 6 PM.

It's the kind of thing no tutorial prepares you for. I don't know if formal education ever really does, either. But I trust my contingency plans enough now that leaving the property without internet — even partially — doesn't stress me out anymore, as long as the services that actually matter keep running. Someone telling me "we have no internet" doesn't rattle me. I just tell them to wait, that I'm working on it.

I've gotten good at following a process when something breaks. But some hardware problems look simple at first and turn out to be genuinely hard to pin down — this was one of them. One of the access points, the newest one in the mesh, was quietly bottlenecking the entire network. Incredible, honestly. These are things I don't see coming. Halfway through the day, I was convinced the real problem was the OPNsense server's motherboard.

Realizing that failures like this can happen at the level of any single component means thinking about newer hardware eventually — not urgent, just something to keep moving toward. The goal isn't making sure this never happens again. It's making sure that when it does, the property keeps running while I'm away.

This post contains Amazon affiliate links. If you purchase through them, I may earn a small commission at no extra cost to you. Every product listed here is something I personally own and use daily.

Monday, August 17, 2026

Automating My Fire Tablet Macrodeck

Homelab · Automation · Quality of Life

Automating the Fire Tablet Dashboard (So I Stop Thinking About It)



The quality of life of the tools I use every day isn't something I'm willing to negotiate on. Throughout this whole process of building a healthy, well-managed network, I've implemented tools I rely on daily — with the catch that I have to keep track of whether I left it on, whether I left it plugged in, or whether, when I sit down to work, I need to charge it first.

More than a technical issue, this is about usability. Getting something to just work automatically usually isn't about skill — it's about taking the time to configure the right solution when the opportunity is already sitting there.

Every new service I add to a well-run network trips the same wire: something has to be started by hand.

The Problem

Two bad options, and neither one respects the hardware.

With this tablet, that meant two bad options. Either I let the screen time out on its own, then plug it back in and wait for it to charge past 2% before I could wake it and reopen MacroDeck. Or I leave it plugged in and awake permanently — and since most of what I repurpose is aging Android hardware nobody wants anymore, permanently-on is its own quiet problem.

The goal was to automate a tool I already use and already trust — not add a workaround for it. Left as-is, the tablet would either be dead when I actually needed it, or slowly wear down hardware that's already past its prime just to stay reachable.

This isn't about being lazy. It's about automating a workflow with tools that are already free and already installed, and keeping the resulting knowledge around for the next device that needs it.

First Attempt

Chasing Windows' own sleep events didn't work.

Of course, none of this was as simple as "enable ADB, add a Windows scheduled task, done." The first version tried to hook directly into Windows' own power events — Kernel-Power Event 42 to catch the system entering sleep, Power-Troubleshooter Event 1 to catch it waking up — firing an ADB script over USB at each transition. Waking worked reliably. Sleeping never did.

The reason took some digging: right as Windows logs that it's entering sleep, the USB controller is already cutting power. The ADB command doesn't have time to complete before the connection dies. It's a race condition against the OS itself, not a misconfiguration — and no amount of tweaking the trigger fixed it.

The Fix

Stop fighting the race. Switch to Wi-Fi, and let a heartbeat do the work.

The fix was to stop trying to win that race. I switched the tablet's ADB connection from USB to Wi-Fi, and let go of the idea that IMPERFECT needed to catch the exact moment it went to sleep. Instead, IMPERFECT sends a simple "still here" signal to the tablet every 58 minutes while it's on. The tablet's own screen timeout is set to 60 minutes. If that signal stops arriving — because IMPERFECT suspended, hibernated, or shut down — the tablet just falls asleep on its own, on Android's terms, with nobody needing to catch the exact moment it happened.

How it works

📶 Wi-Fi ADB — tcpip 5555, no cable needed
💓 Heartbeat — every 58 min while IMPERFECT is on
😴 Timeout — tablet sleeps on its own after 60 min of silence
🔌 Full wake — swipe + MacroDeck, on real resume from sleep

Quick Setup Guide

Get it running on your own tablet.

Requirements: ADB debugging enabled on the tablet, once, over USB

1. Enable Wi-Fi ADB (one-time, over USB)

adb tcpip 5555

2. Disable "stay awake while charging" and set the native timeout

adb shell settings put global stay_on_while_plugged_in 0
adb shell settings put system screen_off_timeout 3600000

3. wake-tablet.bat — full wake, fires on real resume from sleep

adb connect 192.168.2.170:5555
timeout /t 1 /nobreak >nul
adb -s 192.168.2.170:5555 shell input keyevent 224
timeout /t 1 /nobreak >nul
adb -s 192.168.2.170:5555 shell input swipe 300 820 300 205 300
timeout /t 1 /nobreak >nul
adb -s 192.168.2.170:5555 shell monkey -p com.suchbyte.macrodeck -c android.intent.category.LAUNCHER 1

4. heartbeat-tablet.bat — lightweight ping, every 58 minutes

adb connect 192.168.2.170:5555
timeout /t 1 /nobreak >nul
adb -s 192.168.2.170:5555 shell input keyevent 224

5. Two Task Scheduler jobs

One triggered on system resume (Power-Troubleshooter, Event ID 1) running wake-tablet.bat, and one recurring every 58 minutes running heartbeat-tablet.bat — with "start when available" enabled, so a missed cycle catches up the moment the machine wakes instead of getting skipped.

This is tuned for a Fire Tablet running MacroDeck, but the heartbeat pattern works for any always-plugged-in Android device you want to keep reachable without fighting Windows' own sleep timing.

The Point

The simple fix beat the elegant one.

Here's a solution that works — and it feels less like scripting and more like orchestrating: two devices talking to each other cleanly across a network that's already well set up and documented, like a well-run line of dominoes. None of it works without that groundwork already in place.

It's not having to think about turning things on and off, or wondering whether something's charged. This is the first step in automating my workspace — not the last.

What's the oldest device you've kept alive with a script instead of replacing it? Drop it below.

This post contains Amazon affiliate links. If you purchase through them, I may earn a small commission at no extra cost to you. Every product listed here is something I personally own and use daily.

Thursday, July 30, 2026

Beyond the Internet — Watching the Network

Networking · Infrastructure · Monitoring

Beyond the Internet — Watching the Network.

When I first started building my homelab, I wasn't trying to create a lab at all.

I was simply solving a problem for myself. Normally, I build things because a client asks for them. This time, I was the client. Well — the direct client, not the final one.

One service became two. Two became five. Then ten. Before I realized it, the homelab had grown into something that other people relied on every day.

And that changed everything about how I needed to think about it.

Sometimes the internet isn't the problem. Sometimes the network still has work to do — and nobody knows it until someone notices that the photos aren't syncing.

The Problem

The network might still appear online while something important is broken.

A while ago, I created a simple troubleshooting guide so anyone in the house could recover the internet if it went down. That solved one problem.

But the network is much more than internet access now. Today the homelab runs photo storage, a music server, a DNS filter, a firewall, a Cloudflare Tunnel, a service launcher, and an external management system for a client. Each of these services can fail independently — and when one does, the network might still appear "online" while an important part of it is actually broken.

That's when I realized I didn't need another troubleshooting guide. I needed visibility.

The Solution

One screen. Five services. Green or red.

I wanted anyone to be able to glance at a screen and immediately know whether everything was healthy, what service was down, and whether something needed attention. No commands. No SSH. No digging through logs.

Uptime Kuma — a self-hosted monitoring tool — runs in Docker on the NUC. It checks each service every 60 seconds and shows a simple status: up or down. That's all anyone needs to see.

Uptime Kuma showing all services green

Uptime Kuma — 5 services monitored, all green.

Monitored services

🔥 Firewall — OPNsense · 192.168.2.1
🛡️ DNS — Pi-hole · dns.home:8080
📷 Fotos — Immich · fotos.home:2283
🎵 Music — Navidrome · music.home:4533
🔧 Taller — taller.creativelydifferentbuilds.com

The Physical Dashboard

A repurposed Samsung A51 — always on, always visible.

The monitor lives on a Samsung A51 running Fully Kiosk Browser in kiosk mode — screen always on, always showing the status of every service. It connects to Uptime Kuma over the local network at monitor.home:3001.

The goal is simple: anyone in the house — whether they understand the technical details or not — can glance at the screen and know if something needs attention. Green means everything is working. Red means something needs a look.

Samsung A51 showing Uptime Kuma with all services green

Samsung A51 repurposed as a physical dashboard — always on, always visible.

The Launcher

Access for the family — no technical knowledge required.

Alongside the monitor, the service launcher now includes a card for Uptime Kuma. Anyone in the house opens servicios.home:8888 from any device — phone, tablet, or PC — and has direct access to every available service. No IP addresses. No ports to remember. Just names.



The Monitor card is now in the launcher — accessible from any device on the network.

What's Next

The list keeps growing — and that's the point.

As more services come online — home automation, security cameras, a local AI assistant, a family photo album, a music library — each one gets a card in the launcher and a monitor in Uptime Kuma. The infrastructure grows, but the experience stays simple.

Eventually, I'd like to build a guest access system — a QR code menu with curated services for visitors. A pre-selected family photo album. A shared music library. Maybe a local AI assistant. Content that's safe to share, easy to access, and requires nothing more than scanning a code.

That's still an idea. But the infrastructure to support it is already here.

Quick Setup Guide

Get Uptime Kuma running in under 5 minutes.

Requirements: Docker installed on any always-on machine

1. Run the container

docker run -d \
  --name uptime-kuma \
  --restart unless-stopped \
  -p 3001:3001 \
  -v uptime-kuma:/app/data \
  louislam/uptime-kuma:1

2. Open the dashboard

Go to http://[your-server-ip]:3001 and create your admin account.

3. Add a monitor

Click + Add New Monitor → Type: HTTP(s) → enter the URL of your service → set interval to 60 seconds → Save. If the service uses a self-signed certificate, enable Ignore TLS/SSL error.

4. Add a local DNS record (optional)

In Pi-hole → Local DNS Records → add monitor.home pointing to your server IP. Now anyone on the network can open it by name.

There are many detailed guides out there for setting up Uptime Kuma — this is just the version that worked for me. If you run into something specific or need help getting it running in your setup, drop a comment below.

Real World Update

The internet was working. The photo service wasn't.

This is exactly why I built this. The internet was up. The network was running. But Immich — the photo service — went down, and the monitor caught it immediately with a timestamp.

The reason: photos don't have a permanent server yet. Immich runs on my main workstation, and when I shut it down for the night, the service goes with it. That's a known limitation — one that will be resolved when the services move to a dedicated always-on machine. For now, the monitor makes that limitation visible instead of invisible.

As soon as the workstation came back online, Immich recovered automatically. The monitor logged the downtime, the duration, and the recovery — without me having to check anything manually.

Samsung A51 showing Immich down after workstation was turned off

Immich down at 22:43 — timeout of 48000ms. Back up at 22:44 when the workstation came online. The monitor is in Spanish because my wife and kids are native Spanish speakers — the system should work for everyone in the house.

That's the point of visibility. Not to prevent every failure — but to know exactly when it happened, how long it lasted, and when it recovered. Without asking me.

The Honest State

It works perfectly. It looks like a work in progress.

Right now, the A51 is literally thrown on my desk — and it looks exactly like that. Next to the Fire Tablet running MacroDeck, the setup works perfectly but doesn't look intentional. Because it isn't yet.

"If a cluttered desk is a sign of a cluttered mind, of what, then, is an empty desk a sign of?"

— Albert Einstein

I've read that quote many times. And I agree with it — I don't want an empty desk. I want one that looks organized and functional. One that doesn't make a visitor wonder what happened here.

The plan is to mount both the A51 and the Fire Tablet on the wall with permanent connections to the PC. Everything within reach, nothing in the way. The desk stays as the workspace — the wall becomes the command surface.

That's the next project. Unless my mind takes a different route first — which, if you've read this blog, you already know is a real possibility.

The Point

A well-monitored network is one that anyone can trust.

The internet might be fine. But the network has more work to do. And now, anyone in the house can see exactly how it's doing — without asking me.

Green means everything is working. That's all anyone needs to know.

What are you monitoring in your homelab? Drop it below.

This post contains Amazon affiliate links. If you purchase through them, I may earn a small commission at no extra cost to you. Every product listed here is something I personally own and use daily.

Wednesday, July 29, 2026

If It Only Works for Me, It Doesn't Work.

Networking · Infrastructure · Design

If It Only Works for Me, It Doesn't Work.

When I started this blog, it was simply an excuse to write.

A place to document ideas, experiments, and the occasional lesson learned after breaking something.

My homelab started the same way. It began as a technical challenge. I wanted more control over my own infrastructure. More privacy. More ownership over the services I used every day.

At first, everything was built for one person. Me. I knew every IP address. Every port. Every password. Every service had its own bookmark, its own shortcut, its own way of being accessed.

That worked — but only for me.

If every new application requires me to explain "go to this IP address, on this port" — I haven't built a useful system. I've built a puzzle.

The Realization

This infrastructure isn't just mine.

My wife uses it. My children use it. Guests will eventually use parts of it. And hopefully, years from now, they'll use services I haven't even deployed yet.

If every new application requires me to explain "go to this IP address, on this port, using this browser" — then I haven't built a useful system. I've built a puzzle.

Don't Make Me Think

The best systems don't ask users to remember.

One idea has been influencing my thinking for years: Don't Make Me Think. Steve Krug wrote about it in the context of web design, but I believe the principle applies almost everywhere. The best systems don't ask users to remember. They don't require explanations. They simply make the right thing obvious.

I realized my homelab deserved the same treatment.

The Solution

Names instead of numbers.

Instead of asking people to remember addresses like 192.168.2.114:8080 or 192.168.2.20:2283, I configured local DNS records in Pi-hole so every service now has a name:

Local DNS records

firewall.home
dns.home
nas.home
fotos.home
music.home
servicios.home

Pi-hole local DNS records

Pi-hole Local DNS — 6 registros activos, nombres en vez de IPs.

Nobody has to remember where a service lives. Only what it does.

The Launcher

A starting point for everyone in the house.

I built a launcher that lives on any device in the house — a simple page that shows only what's relevant to each person. Not because they need access to everything. Quite the opposite.

The goal isn't to expose every service. The goal is to make the available ones effortless to find. No documentation. No explanations. No technical knowledge required.

It runs on the NUC — the machine that's always on — served by a simple Nginx container. Any device on the network opens servicios.home:8888 and sees it immediately.

Tarjetas de servicios del homelab

Servicios activos y planificados — cada uno con nombre, no con IP.

Launcher de servicios abierto en el Pixel

El launcher abierto en el Pixel — accesible desde cualquier dispositivo en la red.

The Philosophy

This may seem like a small change. Philosophically, it changes everything.

The infrastructure stops feeling like a collection of servers and starts feeling like a product. One designed for people instead of administrators.

Eventually I want to add much more — a local AI assistant, a family wiki, a digital library, internal tools, automation. The list keeps growing. But I've learned something important: every new service should become easier to discover, not harder. Adding functionality should never increase complexity.

External access is a completely different problem. That requires authentication, permissions, reverse proxies, VPNs, and much stricter security. I'll write about that separately.

Inside my network, my philosophy is simple: if someone has permission to use a service, they shouldn't have to think about how to reach it. They should simply open it.

The Point

A well-designed system disappears.

The funny thing is that this has very little to do with servers. It's really about design. A well-designed system disappears. People stop thinking about how to use it and simply use it.

That's the kind of infrastructure I want to build. Not one that impresses me. One that quietly works for everyone else.

If someone has permission to use a service, they shouldn't have to think about how to reach it. They should simply open it.

How do you handle service discovery in your homelab? Drop it below.

This post contains Amazon affiliate links. If you purchase through them, I may earn a small commission at no extra cost to you. Every product listed here is something I personally own and use daily.