Last Saturday, my wife went to a conference. She's my biggest cheerleader, my sounding board, and—as of this weekend—my first real beta tester.
Later that day, she texted me a photo. Her colleague's phone. The app open. And all the buttons? Black text on a black background in dark mode.
Shit.
Welcome to beta, I guess.
There's this moment every founder dreams about. You know the one—the triumphant launch, the confetti, the champagne, the validation that months of work weren't for nothing.
My moment looked different.
It looked like fixing a character count bug on a voice note feature at 11 PM. It looked like realizing I needed a password-protected onboarding flow for beta users. It looked like spending an entire day—50% more time than I budgeted—building a proper update system so beta testers wouldn't be stuck with cached, broken versions of the app.
It looked like a text message with a screenshot of invisible buttons.
Here's the thing nobody tells you about building solo: the last 10% takes as long as the first 90%. Maybe not quite that dramatic, but easily 50% of the total time. And every milestone feels both incredibly exciting and strangely anticlimactic.
There's no team to celebrate with. No co-founder to high-five. Just you, your laptop, and that screenshot reminding you there's always one more thing you didn't think of.
Connect is the app I wish I had every time I came home from a networking event with 15 business cards, good intentions, and zero follow-through. It's 30 minutes of follow-up work compressed into 30 seconds.
Here's how it works:
The problem I'm solving isn't new. We've all been there: pocket full of cards, genuine desire to connect, and then... life happens. The cards sit on your desk. Days turn into weeks. The moment passes.
Connecting in this day and age means you need more than just a "hi, how are you" and a phone number. You need context. You need data you can leverage. You need to move fast.
And strangely enough, that's harder to find than it should be.
They say the last 10% of a project takes 90% of the time. I'm not sure it's quite that extreme, but it's easily 50% of the total time.
The first 90% was exciting:
But that last 10%? That was the real work:
The stuff you don't see coming:
The infrastructure nobody thinks about:
That update system alone—making sure beta testers get fixes immediately without everything caching—took way longer than I wanted. But it's foundational. Not just for beta, but for the entire future of the app.
Because here's the thing: once it's not just me, I can't just refresh my browser and see the fix.
I need a clear path from "bug reported" to "bug fixed" to "everyone has the fix" that actually works. Otherwise beta becomes an exercise in frustration for everyone involved.
Here's what I learned: when you've been thinking about something for 6 weeks straight, you get stuck in grooves.
You develop biases. You have a certain way of working and developing. You make assumptions that feel obvious to you but aren't universal.
When it's just me testing, I know to avoid the dark mode button. I know where the bugs are. I work around them subconsciously. I remember to hard-refresh when I push an update.
But Lindsay? Her colleague? They found them all in 5 minutes.
They expected things to work. They expected updates to just... update. They didn't know they needed to force-refresh to see the fix.
And that's exactly what I needed.
Getting out of those grooves is so critical. That's why beta exists. Not to validate that I built it right—but to discover all the ways my assumptions don't match reality.
I'm launching beta to 5-10 people. Not 100. Not "the world." Just a handful of trusted contacts who:
These aren't random beta testers. They're people in my network who live in the world this app is built for.
They get:
I get:
But more than that: I get to see if the assumptions I made actually work.
As a UX designer, this is where it gets real. People actually using it. And "working" isn't binary—it's grayscale. It's nuance. It's the difference between "this technically functions" and "this actually fits into my workflow."
I'm curious to see if the choices I've made to solve this problem align with how people actually want to solve it.
What if:
These aren't fears. They're questions. And I can't answer them alone in my office.
I have to ship. I have to watch people use it. I have to be okay with being wrong about some things.
And if 10 people say "I love this, but what about Instagram?" or "This feels too focused on networking events"—well, then I know what to build next.
That's the whole point of beta.
It feels like paddling out on a surfboard. Sitting just outside the break, watching the sets roll in.
I've spent weeks building this board. Testing it. Refining it. Waxing it one more time. Adjusting the fins. Then adjusting them again.
I've been watching the waves, timing them, waiting for the right moment.
And now? Now I'm paddling hard, pushing up, and dropping in.
I know the first few rides are going to be rough. I know I might wipe out. I know there will be moments where I wonder if I should have waited for a different wave.
But I also know: the only way to learn if you can surf is to actually catch a wave.
Beta isn't the shore. It's not even the ocean. It's that moment when you stop paddling and start riding.
All the building I've done—the late nights, the rewrites, the "just one more feature" cycles—that was just building the board and studying the break.
Now comes the actual ride.
Beta starts this week.
Then I'll watch, learn, and iterate like crazy for 2-4 weeks.
Then public launch.
My goals for beta are simple:
I'll share what I learn. The good, the bad, and the embarrassingly obvious things I should have thought of earlier.
I'm not going to pretend this is some world-changing startup. It's not.
It's a tool that solves a specific problem for a specific group of people. If it helps 100 people save 30 minutes after every networking event—or coffee meeting, or job site visit, or conference—I'll be thrilled.
But more than that: I set out to build something real, and it's real.
Not perfect. Not finished (is anything ever?). But real.
Real enough to put in the hands of strangers. Real enough to get feedback that will sting a little. Real enough to improve. Real enough that I needed to spend a full day building an update system because other people are going to use this.
And honestly? After weeks of building in isolation, that feels like something worth celebrating—even if it's just me, my laptop, and a quiet sense of: Okay. We're doing this.
I trust myself to land this ride.
Want early access? Join the waitlist and I'll let you know when it's ready for the public launch.
If you're building something solo and feeling like the last 10% is taking as long as everything else—keep going. You're not alone. It really does take that long. And yes, you'll probably spend a whole day on something you thought would take 2 hours. That's normal.
And if you're just curious what happens when someone actually launches this thing—I'll be writing about it. The wins, the fails, the edge cases I missed, and everything in between.
Because if I've learned anything from this process, it's that building in public beats building in silence—even when the public is just a handful of people who will actually read this.
Here we go. 🚀