I started my home automation journey with a single smart bulb. I was one of the early backers of LIFX's Kickstarter campaign, attracted by the promise of controlling lights from my phone. Living with roommates at the time, I only needed one bulb, and the hubless design was perfect. Ten years later, I'm running Home Assistant on an old laptop, maintaining YAML configurations, and have installed enough Zigbee buttons to make my home look like a spacecraft control panel. This is the story of how that happened, and what it taught me about technical debt.
The problem
As someone from Latin America, Northern European winters hit me hard. Not just the cold, but the darkness. Getting up before 9am felt impossible when my body was convinced it was still nighttime. Traditional alarm clocks weren't helping, and I found myself really missing the morning light that used to wake me naturally back home.
The LIFX bulb solved this perfectly. It could simulate sunrise with gradually increasing brightness, shifting from warm tones to cool whites over time. No hub required since it connected directly to WiFi. I set it to start brightening 30 minutes before my alarm, and suddenly mornings became manageable again. As a bonus, I could turn off the light from bed without getting up.
This was the ideal starting point. One bulb, one app, one specific problem solved. The system was simple, maintenance was minimal, and it did exactly what I needed.
The expansion
Black Friday happened. I got a few more LIFX bulbs. Desk lamp? Smart. Nightstand? Obviously smart. I chose the simpler models that focused on temperature and brightness control rather than colors. They worked well, but when I needed GU10 bulbs for the living room, LIFX's prices were hard to justify.
I found Wiz bulbs that offered the same features at a fraction of the cost. They had their own app, but I figured managing two apps wouldn't be too bad. Spoiler: It was. But hey, some of them even had a little physical remote to control them... but only some of them.
Then I visited friends whose house always smelled amazing. They had a diffuser they'd turn on occasionally. I found an automated version with scheduling, remote control, and its own app. I was on a journey to avoid manually operating my appliances!
Within a few months, I was basically a one-man IT department for lightbulbs and other stuff:
- LIFX for the original bulbs
- Wiz for the budget-friendly additions
- A third app for the diffuser
Each had its own scheduling system, its own automations, and its own quirks. If I wanted to match color temperatures across rooms, I had to open multiple apps and eyeball it. Scheduling? Setting times in three different places. Vacation modes? Three separate configurations.
The operational overhead was growing faster than the actual functionality. It reminded me of how microservice architectures can sprawl: each service works fine in isolation, but the coordination cost multiplies with each addition.
Integration attempts
I tried both SmartThings and Google Home as integration layers. They could control basic functions across devices, but lost most of the advanced features. Color temperature became just "warm" or "cool" instead of precise Kelvin values. Scheduling required going back to the original apps anyway.
The real problem became apparent during a vacation to South America. I got a message from my neighbor asking if everything was okay as my apartment lights were going crazy at 2am. The sunrise simulation was still running on European time. Each app handled time zones differently, and I hadn't realized I needed to manually adjust all three before traveling.
This was a classic distributed systems problem. No single source of truth for time, no coordination between services, and the user (me) as the only integration point. I spent time from my glorious vacation manually turning off automations through various apps to avoid disturbing the neighbors.
The reality check
When my wife entered my life, the system's flaws became immediately apparent. As a single developer (I mean, person living alone), I had built the perfect system for exactly one user: me. What worked for me fell apart with a second person who had the reasonable expectation that lights should work normally.
I would hear: "Why are the lights having a disco at 6am?". A fair question when the sunrise simulation kicked in unexpectedly. Or the recurring: "The switch doesn't work!". It did, you just had to flip it twice, but not too fast, and not too slow either, juuuust right. She had a point though: Why should turning on a light require a smartphone, let alone three different apps? When she asked me to turn off the bedroom light before sleep, it highlighted how I'd made a simple task needlessly complex. (Though to be fair, she asks me the same even when the analog switch works just fine.)
I had become the human interface to our home's lighting system. Every adjustment required my intervention. The smart bulbs had broken the basic contract of a light switch: flip it and the light changes. Instead, we had a system where physical switches were essentially broken, and everything required going through apps that only I had configured. I quickly learned to recognize the "your smart home is being dumb again" look.
The more I tried to explain the "proper" way to use the lights, the more obvious it became that I had over-engineered a simple problem. My wife wasn't wrong to expect light switches to just work—she was absolutely right. Her feedback was the user perspective I desperately needed. I had prioritized clever automation over basic usability, and she patiently dealt with my experiments while consistently advocating for what actual users need: things that just work.
Home Assistant changes everything
After researching solutions, I discovered Home Assistant. The setup wasn't trivial. It took a weekend of configuring Docker, learning UI and YAML editors, and migrating all my devices. But once running on an old laptop I had repurposed as a media server, it transformed the entire system.
Home Assistant automatically discovered all my devices across different vendors and unified them into a single interface. I could finally create room-based controls, unified schedules, and consistent automations. Most importantly, I could create different dashboards for different users.
Together, we designed a simple interface with just the controls she needed. Her input was invaluable in determining what actually mattered versus what was just tech for tech's sake. I kept a more detailed view for configuration and monitoring. We mounted an old phone on the living room wall as an additional control panel, with one-touch scenes like "Movie Time" that dimmed lights and turned on the TV.
The sunrise automation became smarter: gentler on weekdays when we both needed to wake up, off on weekends, and completely turned up to 11 when my wife was traveling. The system could finally respond to context rather than just following rigid schedules.
Of course, I was now maintaining a server, configs, backups, and whatnot. The technical overhead had shifted from multiple apps to a single complex system. But at least it was a system that actually worked for both of us. Bonus point for not needing the cloud for the system to work.
The physical interface problem
The core issue remained: smart bulbs had broken our light switches. The "correct" solution would have been smart switches controlling dumb bulbs, but I was already invested heavily in smart bulbs. Instead of starting over, I found Zigbee buttons: small, battery-powered switches that could be placed anywhere.
After some wrestling with Home Assistant to install the Zigbee controller, I installed the buttons everywhere. One above each traditional switch, creating a parallel control system. Buttons on both nightstands for bedroom control. Some in the kitchen and the dining area. A few in the living room. One on my desk to control office lights, because why get up when I can automate it? The setup grew organically based on where we actually needed controls.
Each button supported single click, double click, and long press, mapped to different functions. Single click toggled lights, double click activated scenes, long press controlled dimming. It was flexible and powerful, but explaining it to guests became a comedy routine. "The light switch doesn't work, but the button above it does. No, not that button, that's for the hallway."
I had essentially created a second layer of infrastructure to work around the broken first layer. It was the physical manifestation of technical debt. Instead of fixing the root problem, I added complexity to work around it.
What finally works
Today's system is stable and, surprisingly, both my wife and I are happy with it. Several key principles emerged from all the iterations:
Master kill switch: Every automation checks a global "automations enabled" flag first. One toggle disables everything when we have guests or just need predictable lighting. This saved us during multiple family visits when explaining the smart home complexity wasn't worth it.
Layered redundancy: The system degrades gracefully. Everything runs locally, so internet outages don't affect basic operation. If Home Assistant crashes, physical switches still cut power as a last resort. The Zigbee buttons need the coordinator running, but at least we're not dependent on cloud services.
Configuration as code: Everything lives in YAML files, version controlled and backed up. I can rebuild the entire system from scratch if needed, though the initial configuration took days of tweaking to get right.
Automation restraint: Early on, I automated everything possible. Now, we automate only what genuinely improves daily life. Sunrise simulation, yes. Lights that follow you room to room, no. The best automation is invisible and predictable.
Lessons for software architecture
This journey mirrors so many software projects I've seen:
Starting simple is not a weakness: That first LIFX bulb solved my actual problem perfectly. The complications came from expanding beyond the original need without reconsidering the architecture. It's the classic trap of growing a prototype into a production system without redesign.
Users define success: My wife's feedback was direct and insightful and exactly what I needed to hear. If your primary users can't operate the system without help, you've failed, regardless of how clever the implementation is. Technical elegance means nothing if it doesn't serve user needs. She helped me see that I wasn't building a smart home; I was building a complicated home.
Integration complexity compounds: Each new app didn't just add linear complexity, it multiplied the coordination overhead. The same happens when adding external services to software systems. Three integrations means three APIs, three failure modes, three sets of credentials, and exponential interaction patterns.
Sunk cost drives bad decisions: I kept adding layers (buttons, automation, configuration) rather than addressing the fundamental issue that smart bulbs and physical switches don't play well together. How often do we patch systems rather than fix root causes because we're already invested?
Kill switches save systems: That global automation toggle is the most-used feature. Complex systems need simple overrides. Whether it's a feature flag, a circuit breaker, or a "turn off all the clever stuff" button, the ability to quickly revert to simple behavior is invaluable.
Conclusion
After years of iteration, I have a home automation system that works well for both technical and non-technical users. Each decision along the way made sense with the information and constraints I had at the time. The complexity emerged not from bad decisions, but from how those decisions aged as the context changed.
The irony isn't lost on me: I spent years and hundreds of euros to recreate what we already had: a way to control lights. But now it's a light switch that knows about sunrise times, responds to our presence, and creates perfect movie ambiance with one button press.
Was it worth it? From a pure functionality perspective, probably not. From a learning perspective, absolutely. Every over-engineered solution, every patch upon patch, every frustrated user interaction taught me something about system design that I carry into my professional work. And I had a blast doing it! Although, I no longer walk around thinking "Hmmm... what else can I automate?"
The wife approval factor is at an all-time high, even though she still tells people about how I "fixed" our lights. "He added all this technology," she says pointing at the wall of buttons, "to reinvent the light switch." She's definitely not wrong. But at least now when she asks me to turn off the bedroom light, she can do it herself with a button, an app, a voice command (to me), or in an emergency with the actual light switch.
Sometimes the best solution is the one that just works, even if it took a ridiculous journey to get there.