The App I Built So I Wouldn't Have to Fly to Europe Every Time Life Got Heavy

Here's where this actually starts. Not with a line of code. With a plane ticket.

This past spring I flew to Europe in rough shape. Not dramatic, made-for-TV rough shape. Just the slow kind. A little depressed, a little run down physically, stuck in that mode where I was getting through my days instead of living them. I needed to get out of my own house and my own head for a while… so Laura, my wife, took her turn with a trip of her own, and then it was mine.

And it worked. Better than I expected. New streets, new light, new food, a new version of myself to replace the one that had checked out for a while. I came home lighter. The problem was obvious somewhere over the Atlantic on the flight back: I can't fly to Europe every time I need to feel something. Nobody can. That's not a strategy. It's a very expensive coping mechanism.

But by the time I landed at O'Hare, I'd already figured it out. The trip itself wasn't the point. The point was that for two weeks I'd been paying close attention to my own life. Noticing things. Being present for them instead of scrolling past them.

I didn't need Europe for that. I needed to bring the same attention home and aim it at an ordinary Tuesday. Grocery runs. Bedtime with my boys. A good conversation with Laura on the couch. I wanted the same joy out of the life I already had, without needing an eight hour flight to unlock it.

So I asked myself a different question. What if I built something that gave me a little bit of that feeling every day? Not a trip. A habit. Something that made me pay attention to the good stuff already sitting in my life instead of waiting for a crisis to notice it. Something that turned "I should really work on that" into an actual record of whether I had.

I'm a software engineer by trade. That's not a hobby I picked up, it's what I do for a living… and it's the tool I reach for whenever I'm trying to solve a problem in my own life. So instead of just journaling about the feeling (which I had already done many times), I opened a code editor and started building the thing that would hold it.

That thing is called Layer Cake. The name comes from how the app actually works: nothing in it happens all at once. You write a little today, check in on a goal tomorrow, and each small thing you do gets added on top of the last one. Goals aren't achieved in a day. They're built in layers, and the app is designed around watching those layers stack up until they amount to something.

Plus, I just love cake.

Before It Was an App

Before this app was even an idea, I had two Notion boards. Laura set me up with them a few months before Europe, trying to pull me out of my funk. One asked a simple question every day: What am I grateful for? The other asked something even simpler: What was the best thing that happened to me today?

It worked… for about two weeks. Then it fell apart, and the reason it fell apart is the whole reason this app exists: nothing was holding me accountable, and nothing connected any of it to the things I actually wanted to change. Notion didn't care whether I showed up. No streak, no reminder, no record of the gap. Gratitude entries collecting in one place, goals sitting untouched somewhere else. The habit just faded, the way habits do when nothing notices them.

So when I started building Layer Cake, those two questions were the first thing I rebuilt. But I didn't want to build another gratitude app with a different skin. There are plenty of apps that ask you a nice question every day, and they all fail the same way: pleasant entries piling up, attached to nothing. The difference had to be the journal entries’ connections to goals, or there was no point building it.

And my two original boards ended up being the real heartbeat of the whole project. I wasn't building a goal tracker first and adding gratitude as an afterthought. I was building a daily habit of noticing, and the goal tracking grew up around it. That order matters. It's the difference between an app that nags you about productivity and an app that just asks you, every day, to look for the good part in what you did.

The First Build

Every app starts as a small idea before it turns into something bigger, and mine was no exception. A vision board I could share with the people close to me. Not an account, not an app they'd have to install. A web link. That was the whole pitch, to myself, late one night.

I'd fill this board with things I wanted to be better at. Things I needed to improve on. And then share it with Laura in hopes that the act of sharing a static board would somehow, magically, make those things come true.

But I quickly realized vision boards have a design flaw. You make a nice collage of the life you want, you look at it sometimes, and then nothing happens. Nothing connects the picture to the Tuesday afternoon, for instance, where you actually do something about one of those goals. The board just tells you to want it harder… but wanting isn't a step. Neither is the universe. So when a goal does come true, there's no trail of work to look back on. Just "I manifested this," which isn't actionable.

I wanted to build that bridge.

I did what I always do when I'm testing a concept: I threw together a quick static page first, just to see if the interaction felt right before committing to real infrastructure. It did. So I rebuilt it properly as a Progressive Web App with a backend handling the dynamic parts through a proper API, with login, and a database.

The PWA still runs as one file. Sixteen thousand lines, one document. That's deliberate: when you're the only person maintaining something, one file means every bug has exactly one place to hide.

Sharing It With Laura

Sharing was always the idea, but I'd pictured it one way: you make a board, you send a link, someone looks at it. Then I showed Laura one I'd created for the both of us, Our Life 10 Years From Now, and it was obvious within a day that looking wasn't enough. It was her life on that board too. She wasn't going to just view it.

That realization opened up an entire side of the app I hadn't planned for. Collaborative vision boards. And once two people could be in a board, it needed permissions: someone who can edit versus someone who can only view. Once two people were using a board together, they’d want to react to each other's posts. Then comment on them. Then leave written reflections on specific things the other person had added.

None of that was on my original list. But each piece made the app feel more like a real product and less like a personal notebook I happened to be showing off, so I kept building it out.

Going Native

This wasn't my first iOS app. But it was the biggest port I'd ever taken on. By the time the PWA hit 16,000 lines, I knew I needed a real native app, and part of the reason was simple: I wanted push notifications that actually worked, instead of relying on email reminders that get buried, marked as spam, or ignored entirely. Native push meant the app could reach you the moment it mattered, not whenever you happened to check your inbox.

It would also be more performant and SO much cooler.

Porting that much logic into Swift for iOS wasn't a weekend project. I spent a LOT of time running the PWA and the native build side by side on my phone, checking that a streak calculated the same way in both, that a reflection saved the same way in both, making sure sixteen thousand lines of decisions carried over correctly instead of drifting apart without my noticing. The PWA stayed alive as a fully functional, feature complete entry point, something anyone can use without downloading anything. But the real depth of the app, the richer logic, the fuller feature set, lives in the native apps.

The Cake

Every app needs a reason to open it besides duty. Streaks work for a while, but they're punishing. Miss one day and the whole thing resets, and that's the opposite of what I wanted this to feel like.

I wanted something that accumulated no matter what, so I built Frosting. Every time you write, reflect, work toward a goal, or complete a challenge, you earn Frosting points that build a cake. Layers rise, flavors get assigned, decorations show up based on exactly what you did: sprinkles from reflections, stars from goals a user finished, candles from streaks, flowers from completed challenges (which I eventually renamed "Recipes"). Fill the cake and it joins your bakery. A new one starts.

The graphics work behind this turned into one of the more interesting technical problems I've solved recently. Getting a cake to render smoothly as it fills, getting flavors to look visually distinct, getting frosting to actually read as frosting instead of a beige smear, that all took real iteration. Porting the animated version to iOS meant solving a problem I'd never had a reason to think about before: getting a looping GIF of a flickering candle to export without the color banding you get from basic GIF compression. That sent me down a rabbit hole into an old image dithering technique that solved it cleanly. That's the part of building software I actually enjoy.

Recipes, Challenges, and the Bakery

Journaling alone can turn into a diary of good intentions, so the app also hands you things to do.

In the theme of Layer Cake, Recipes are guided multi-day programs, one task per day, written in the same voice as the rest of the app. Fix the thing that's been bugging you. Look hard at your money. Ask for the better deal. Mine was gratitude, which sounds soft until a custom Recipe breaks it into actual assignments: thank someone who doesn't know they helped you. Write down a hard thing that turned out to be good for you. Notice the thing you'd miss most if it disappeared tomorrow, and do something about it today. That action needed to be tangible. Every one of the steps ends with something you did, not something you felt.

Weekly Challenges are single real-world tasks with a deadline built in: the week ends whether you did it or not.

They each pay out in their own currency. Finish a Recipe and you earn a cupcake. Finish a Weekly Challenge and you earn a cake pop. They join your cakes in the bakery, which is exactly what it sounds like: a shelf of everything you've earned, each one tied to something you actually did. Forest players will recognize the trick. It's a little silly. You'll want to fill and share the shelf anyway.

Built for People Who Want to Move, Not Wait

At one point I read back through my own help text and didn't like what I saw. It had drifted into the same self-help register every app in this space defaults to. Rewiring your brain. Honoring your journey. Trusting the process.

If I downloaded an app and saw that voice, I'd delete it inside of ten seconds. I'm not building this for someone waiting on the universe to sort their life out for them. I'm building it for people who want to actively move things forward themselves, one entry at a time. So I went through the entire app and pulled that language out by the roots.

The check-in help section is the best example. I legit did research on this stuff, neural pathways, the brain's attention system, and wrote something that read like a psychology textbook. Accurate, probably. Unreadable, definitely. So I kicked myself and rewrote it with something more approachable instead: athletes review old game film, entrepreneurs reread their own business plans, and repetition like that changes what you notice in your regular life. It's not magic. It's just paying attention on purpose. That became the voice for the whole app. Direct, a little dry snark, no spiritual language anywhere.

Linking, Check-ins, and the Part That Actually Holds You Accountable

Here's the mechanism that makes the whole thing work.

Every entry you write, whether it's a quick gratitude line or a real update on a goal, can be linked directly to something on your vision board. That link is the receipt. Over time, each goal builds a running trail of the actual entries that moved it forward, not just the picture you posted of it back in January.

Check-ins are how you take accountability. You sit with your board on a regular basis and mark where each goal actually stands: moving toward it, drifting away from it, holding steady. For those in Agile software, you might realize this sounds a lot like Daily Standup. It is. And that is exactly why I built it this way.

A heatmap tracks your consistency over time so you can see your own effort laid out visually instead of just trusting your memory of how often you showed up.

And the app closes the loop. If you've told it a goal is a priority but haven't linked a single entry to it in weeks, it tells you. No guilt, just the truth about where your attention's been going. That's the whole promise of this app in one feature: surfacing the gap between what you say you're working toward and what your actual trail of entries shows.

Notice the wording, though. The app doesn't hold you accountable. Nothing outside of you ever really does. It keeps the record clean enough that you can't fool yourself, and it turns out that's most of the battle.

And that trail isn't just bookkeeping. When you finally achieve the goal, it becomes the raw material for my favorite feature in the whole app. More on that in a minute.

This is the bridge I set out to build from the start. It works if all you want is a daily nudge to work towards those things on your board. It also works if you want to build real infrastructure around a goal that actually matters to you and hold yourself to it. The tagline says it plainly: Vision boards show what you want, Layer Cake shows what you're doing about it. Every time you open the app, you get a real look at where you stand. Not where you wish you stood.

My First Android App, and Why iOS Developers Don't Make Android Apps

This was my first Android app, ever, and I now understand at a cellular level why so many iOS developers just don't bother crossing over. The dependency management alone could make a grown man cry. Every solution seems to require three other tools, each with their own setup, each with their own way of breaking something that worked five minutes ago without warning. The bloat is real. Kotlin is… Kotlin. I went in expecting a straightforward port and came out with genuine respect for how much simpler the iOS side of this whole project has been by comparison.

Sorry, if you're an Android developer.

You can read that both ways.

That said, I got it done. Feature parity with iOS, same design language, same cake, same everything, built from scratch in a completely different language with a completely different set of tools. I hit bugs that were specific to how Android handles things under the hood, screen rendering during export (do not get me started on screen rendering), permission systems that behave differently depending on how old the phone's operating system is. Every one of them got solved. None of them were fun in the moment. All of them made me better at this.

The important part: both sides of the aisle can use this now. Half the point of Layer Cake is sharing boards with the people in your life, and you don't get to pick what phone those people carry. A collaborative vision board that only half your family can open isn't collaborative. It's exclusive. Now the whole household is invited, green bubbles and all.

Yes, There's AI in It…

I'll say this plainly since I know where I'm posting this. The app uses an optional AI model for a few things, and all of them are built the same way as everything else here: your data is yours and you're always the one in control. Turn the AI off entirely (it's off by default) and Layer Cake still works, whole and complete. The boards, the linking, the check-ins, the cake, the recipes, none of it needs a model to function. What the AI adds is on top of the experience, never underneath.

Everything below runs on the same engine: a memory. As you write, the app distills what actually matters to you. The goals you keep circling, the people who keep showing up, the thing you said you'd start back in March. That memory is why a prompt can feel aimed instead of random, and why a letter can read like it came from something that actually read you. And it's fully yours: open it, read every line the app believes about you, correct it, steer it, or wipe it clean. Nothing in there is hidden and nothing is permanent.

Journal prompts, first. Instead of the same rotating questions every day, the app can generate a prompt tailored to what you've actually been writing about, and it remembers what it's already asked you so it doesn't repeat itself.

Link suggestions, second. After you save an entry, the app can suggest which goal it might connect to, based on what you actually wrote. You can always do this manually, but the auto-suggestions feel more magical. It never links anything on its own. It surfaces a suggestion, you tap to confirm it, or you don't.

Recipes, third. Tap a goal and the app builds a custom Recipe around it complete with 3 or 5 days of custom, actionable tasks that help push you towards achieving something. Made for that goal, not pulled off a shelf.

Goal Stories, fourth. This is my favorite, and the real trophy in the app. The cake is fun. This is the thing worth chasing. Achieve a goal and the app can write up the story of how you did it, offering observations and insight on the climb, pulled from your own entries and check-ins. The rough stretch in March, the week it turned around, the entry where it clicked. Not a summary a stranger wrote. Your words, your climb, distilled and presented back to you, showing you did this. Not the universe.

The Weekly Check-In Letter, fifth. Once a week the app writes you a short letter about how things are actually going with your goals. Which ones moved, which ones went dark, what the entries say when you read them all together. Built entirely from your own writing, links, and check-ins, in a voice that's warm but doesn't flatter you. Like a friend who reads everything and tells you the truth.

And if you'd rather the AI keep its hands off a particular goal entirely, you can mute it. The AI does the remembering. You always do the deciding.

Everything you write is private by default and encrypted in transit and at rest. Your entries are yours and you can export all your data at any time. That's consistent with everything else I've said here. This isn't an app that does the work for you. It's an app that makes it easier to keep an honest account of the work you did yourself.

One more up front note while I'm at it. The core app, everything outside that AI list, is free and complete. The AI features will eventually be a subscription with a free trial after the beta period, because every letter and every story costs real compute money to write, and I'd rather charge honestly for that than get creative with your data. Turn it off, never pay a cent, and Layer Cake is still whole.

Where It Stands

Layer Cake is live in beta right now. A native iOS app, a native Android app, and one shared backend underneath them, running on a private encrypted server. The two boards I originally made for myself, gratitude and best thing that happened today, are still there, and I still use them every day.

And at some point, the app started building itself: Layer Cake milestones went on my own vision board as goals, and the entries piled up underneath it until it shipped… and I LOVED reading those Goal Stories after each was achieved. Every feature in this post spent time as a linked entry first.

If you want to try it, you can learn more at layercake.me and find the current links for the iOS and Android betas.

I didn't build this because I had a business plan. I built it because I came home from a trip that helped me notice my own life again, and I didn't want that to fade the second the jet lag wore off. I wanted habits that could hold onto it. Somewhere along the way those habits turned into three platforms, a gamification system I'm genuinely proud of, and a small collection of cakes with flavors I'm still inventing.

I don't know exactly how many people will end up using this. I know it does exactly what I built it to do, which is remind me, and hopefully you, that the good part of your life isn't always somewhere else. Sometimes it's just something you did today. The entry is the receipt.

Vision boards show what you want. Layer Cake shows what you're doing about it.

‍