Tokyo Smart Home

My apartment on the 47th floor of a Tokyo high-rise runs on half a dozen ecosystems that were never designed to meet: SmartThings air conditioning and sensors, Z-Wave lighting, two Volumio music streamers, a Denon AV receiver, and cameras. Each shipped with its own app, its own login, and its own opinion.

Home Assistant can unify all of it — it is the most capable smart-home platform there is, and famously unapproachable. Out of the box it’s a tool built by engineers for engineers: infinitely flexible, visually generic, and a dashboard you’d actually want to live with is not something a non-coder can build. The capability is all there; the experience isn’t. That gap is a design problem, and it’s the one this project exists to close.

So I designed and built a single custom interface on top of Home Assistant that replaces all of it — a wall-mounted tablet as the home’s primary surface, with the same experience responsive across desktop and phone. My users are the hardest kind to satisfy: my family, every day, in two houses.

The smart home has been promised for thirty years, and I should have been the person it came easy to — my whole career before design was systems integration and security. Instead I spent the better part of two decades fighting the wrong half of the problem: not whether it could work, but whether it could be beautiful and trustworthy at the same time.

The fight was always the protocols and the interface. X10 could switch a light but couldn’t tell me whether it actually turned on; SmartThings could make devices talk but never gave me a dashboard worth living in; ActionTiles finally did — until its servers went dark overnight and took every screen in the house with them. If it lives in someone else’s cloud, it isn’t mine. And nobody owns this market, so every choice — a wall-switch module, roller blinds, a water sensor — is a gamble: built around a protocol today, discontinued tomorrow, with no standard to bet on.

Home Assistant was the first platform open enough to escape all that — but its stock dashboards are built by engineers, for engineers, and the promise kept dying on the last mile: the interface. What finally closed the gap wasn’t a new protocol; it was AI. I could hand off the execution and finally build the system that was always supposed to exist — the judgment still mine, the labor no longer the bottleneck. It doesn’t try to be everything; it does exactly what I need, built to grow when I do. It’s a utility — and after twenty years, a trustworthy one.

I built this for my own house — but strip away my rooms and my family’s habits and the design underneath serves anyone who wants their home to feel like one calm, trustworthy place instead of a drawer full of apps. It always starts the same way: a house full of “smart” things that never became a home.

He designs beautiful spaces for a living, and his own home runs on a dozen apps that look like engineers built them — because engineers did. For him, amazing is a control surface as considered as the rooms it controls.

Marco’s journey is the gap between how good his home looks and how badly its controls behave — and the day that gap finally closed.

Three generations live under her roof, from a father in his eighties to kids who’ve never known a world without touchscreens. For her, amazing is one surface every single one of them can actually use — no one left out, no one calling her for help.

Grace’s journey isn’t about features — it’s about whether the least technical person in the house can walk up and win, without her.

He lost a whole smart-home setup once when a company switched off its servers overnight — and he’s never trusted the cloud with his house since. For him, amazing is a home that runs on his own network and answers to no server but his.

Ravi’s journey turns on a single question the cloud can never answer honestly: when the servers go away, is my home still mine?

Forget the six systems for a second. The perfect version of this isn’t a wall of controls at all — it’s a home that simply behaves. The room is the right temperature. The record plays. The light you tapped is on, and the screen agrees. You never wonder whether it worked, and you never think about the six systems underneath.

Nobody ships that, and here’s the wall: the pieces come from half a dozen clouds that were never meant to meet, wrapped in dashboards built by engineers for engineers. The capability is all there; the calm isn’t. The only thing that closes that gap is trust — state you can believe, one language across every device, and a system that answers to you and not to someone else’s server.

Getting a solo designer anywhere near that used to be impossible — it’s a team’s worth of engineering. What changed is the collaborator. AI didn’t design this home, but it’s the reason one person’s design judgment could actually become a working, trustworthy product on the wall.

Home Assistant became the integration hub; the custom dashboard became the family’s single point of contact. Climate for every unit with per-room control, whole-home lighting grouped the way the rooms actually work, scenes, automations with visible state, accurate local weather from a custom-built forecast integration — and the entire music system. Nothing requires knowing which brand made which device.

Temperature displays in both units, everywhere it appears — my wife reads Celsius, I read Fahrenheit, and the interface simply respects both instead of making one of us do arithmetic.

The interface was designed in Figma before a line of code — a dark, typography-led language built for a screen that lives on a wall: readable across the room, calm at night, thin uppercase display type with a single accent color for state. Every control gives immediate feedback — an optimistic visual response plus a subtle audio cue — and long-press reveals detail views for anyone who wants more than the surface.

Dashboard templates exist and they all look like dashboards. This looks like the apartment it lives in.

The music page carries the full chain: now-playing with artwork and hi-res badges, a live queue, a library browser spanning two streaming services and local storage — and the amplifier’s controls beside them: press-and-hold volume ramp, mute, and one-tap source switching between the streamer and the turntable’s phono stage. Selecting an album never blasts music unasked — it cues it, ready to play.

Everything is optimistic: the interface updates the moment you act and reconciles with the real device state behind the scenes, so a slow cloud link never makes the room feel broken.

The user problem that kills home dashboards is state that lies. A cloud integration that silently goes stale means a tablet that shows lights on when they’re off — and a family that goes back to wall switches forever. So I treated reliability as part of the UX.

On the night of August 11, 2026, Typhoon Chan-hom passed thirty-three kilometers from this apartment — and the dashboard got the test no prototype can fake. The typhoon warning system on these screens — the days-ahead alert, the track map redrawn in the house design language, the escalation that starts pulsing when the storm is close — was designed, built, and argued over that same week, and photographed here live, mid-storm, with real rain on the glass.

The storm didn’t just test the system; it redesigned parts of it. Mid-evening, watching the display disagree with the window, I rebuilt the weather language live around one rule: the interface may only claim what an instrument observes. Rain from the gauge, wind from the anemometer — “heavy rain & windy” on these screens is not a forecast, it’s a measurement. Warnings speak to risk; the display speaks to fact.

The same three surfaces on the phone — one responsive codebase, so the person sheltering in the bedroom reads exactly what the wall in the living room says.

Alongside the typhoon system — which works in days — the board watches for the threat that works in seconds. A live connection to the JMA emergency-warning stream drives a full-screen alarm designed to arrive before the shaking does, and a seismic map drawn in the interface’s own language. The whole chain is drilled against the real thing: siren, warning screen, and the map replaying a real magnitude 5.9 from 1,299 observation stations.

The interface is one responsive codebase — the wall tablet’s layout, the desktop’s, and a phone experience designed mobile-first in Figma with a bottom tab bar, running as a home-screen web app. Same features, same design language, same single source of truth — sized to the hand, the desk, or the wall — because a home interface only stays trustworthy when every screen tells the same story.

And it isn’t bound to the apartment. It runs on the local network and, through Nabu Casa’s cloud relay, from anywhere — so the same phone that dims the lights from across the room does it just as well from the other side of the world.

There is no design-system page behind this project — the wireframe set is the working documentation. Here is the mobile spec in full: the four views, the tertiary flows, and the long-press popups, exactly as they were drawn before the code existed.

This one is niche by design. My daughter is two, she has firm opinions about Anpanman and Mickey Mouse, and the family had a ritual that was not working: switch on the set, pick a profile, hunt through “recently played” with a remote for the compilation she actually wanted. The TV’s own app is built for adults browsing. What the household needed was a controller for one child’s library, on the wall tablet everybody already uses.

The tab talks to the set over a debug bridge rather than a cloud service, which is what makes it honest. The hero is a true now-playing tile: the television itself reports the title and channel of whatever YouTube is showing, whether the tablet started it or someone picked it with the remote, and the thumbnail follows once the video is identified. Power lights the moment you ask for video and yields to the set’s own state; volume ramps while held, with the TV’s real level beside the circles. Every control is the music page’s idiom: circles for device controls, squared type for actions, one accent colour for state.

The playlists are ours, not the algorithm’s. Each tab is a curated list; a tile plays that one video and lets YouTube carry on, while “play all” runs the list in order and shows you the queue. Long-press a tile to remove it, long-press the hero to add what’s playing to a list of your choosing, with duplicates refused. A shuffle deals from every list in turn, so the grown-ups on the couch are not sentenced to the same ten minutes on repeat. It is the smallest project on this page and the one that gets used every single day.

This is the first project in this portfolio built in partnership with AI — and it changed my process less than you’d think, in exactly the right way. The design still starts where it always has: real user problems, a Figma spec as the source of truth, and my judgment on every pixel that ships. What AI collapsed is the distance between design intent and running product.

The loop is fast and conversational: I describe the intent, the AI builds it, I use it on the actual wall tablet, and I critique it like I’d critique any designer’s work — too heavy, wrong weight, doesn’t match the spec, users won’t find that. Iterations that once took a sprint take an afternoon. And the partnership runs deeper than pixels: the reliability engineering above — the watchdogs, the proxies, the failure analysis — was debugged the same way, out loud, together.

That pairing is what feels genuinely new. AI can build almost anything you describe — but it doesn’t know when a thing is right: when the weight is off, when a screen looks finished but doesn’t feel it, when a user’s eye won’t land where it should. Knowing what looks right and feels right — what makes a user’s eye happy — is what two decades of the craft buys you. Put that eye next to something that builds as fast as you can describe it, and you get further than either would alone — the judgment to know what to make, and the speed to make it.

A home interface is never really shipped — it’s lived in, and living in it is the research. What the family reaches for, where a guest hesitates, the device that shows up and demands a place: that’s the feedback, and it comes back to me as the next brief.

It has run for months as the household’s primary interface — and when something new arrives in the apartment, the question is no longer “which app?” but “when does it go on the tablet?” It’s never really finished: a living, evolving interface, built to scale — as more lights, automated blinds, and new systems come online, each one earns a place in the same language rather than another icon on the pile.

My earliest case studies here were drawn by hand, before Figma existed and long before AI. This one closes the loop: designed in Figma, built in partnership with AI as an engineering collaborator, refined the same way as ever — by listening to the users who live with the result.