Shipping Solo: How I Built 5 Apps Without Losing My Mind

I've shipped 5 apps in the last 3 years. Not all of them made money. Two of them live exclusively on my laptop, used by nobody but me. But every single one taught me something real about building alone.

Here's the thing nobody tells you about solo development: the code is the easy part.

The hard part is everything else. The icons. The screenshots. The hundred small decisions that have nothing to do with logic and everything to do with shipping. The motivation that evaporates around week three when the novelty wears off and the real work begins.

I'm not special. I don't have 20 years of experience or a CS degree from Stanford. I'm just a developer who got tired of never finishing things and decided to figure out why.

The Myth of the Solo Dev

There's this romantic image of the solo developer — a lone genius in a coffee shop, headphones on, typing furiously, emerging weeks later with a perfect app. It's nonsense. Real solo development is messy. You're not just the developer. You're the designer, the QA team, the product manager, the marketing department, and the person who has to talk to support at 11 PM on a Saturday.

The first app I built took 8 months. Eight months for something that, looking back, should have taken 6 weeks. Why? Because I kept getting stuck on non-code problems. I'd finish a feature and then spend 3 days trying to make an icon that didn't look embarrassing. I'd write code, lose it somewhere in my file system, and rewrite it a week later because I couldn't find the original.

I was context-switching between a dozen different tools, and none of them talked to each other. My new tab was a search bar. My notes were scattered across three apps. My code snippets were a junkyard of random text files.

Something had to change.

How I Actually Build Now

After 5 apps, I've settled into a workflow that doesn't require me to be a genius. It just requires me to be consistent. Here's exactly what that looks like.

Prototyping: Fast and Ugly

I don't open Figma first anymore. I open ZeroPad. It's my new tab page — a blank markdown editor that appears every time I open a browser tab. I dump everything there: rough ideas, feature lists, UI sketches in ASCII, questions I need to answer later. It autosaves instantly. No file management, no folder structure, no friction.

ZeroPad stays open as a persistent scratchpad for the entire life of the project. When I need to find something I wrote three weeks ago, I just scroll. The search is instant. It's all local, so I don't worry about privacy or internet access.

From there, I crystallize ideas into a single markdown file: one-pager, technical decisions, launch checklist. That file lives in ZeroPad until the project ships.

Writing Code That Sticks

I used to write utility functions, forget about them, and rewrite them months later. Then I started using Snippet Ark.

Here's the deal: every time I write something I might need again — a date formatter, an API client wrapper, a SwiftUI modifier I spent 30 minutes debugging — it goes into Snippet Ark immediately. Tagged, searchable, synchronized across my machines.

The ROI here is absurd. I'd estimate it saves me 2-3 hours per week. That's not a guess — I actually tracked it for a month. Before Snippet Ark, I'd spend an average of 17 minutes hunting down code I knew I'd written. Now it's under 30 seconds.

The trick is making it frictionless. If saving a snippet takes more than 5 seconds, you won't do it. Snippet Ark gets this — you hit a keyboard shortcut, paste your code, add a couple of tags, and move on. No folders to create, no naming conventions to memorize, no decision fatigue.

My most-used snippets right now:

• A SwiftUI button component with loading state and error handling
• A JavaScript debounce utility with proper TypeScript types
• A Docker Compose template for local PostgreSQL + Redis
• A Stripe webhook verification snippet with idempotency checking
• An async retry wrapper with exponential backoff
• A bash script for creating a new React component with test file and stylesheet

Every single one of those saved my ass at least twice. The bash script alone saves me about 20 minutes every time I start a new component. And I start new components a lot.

If you're not saving your snippets, you're throwing away your own time. It's that simple.

The Icon Problem

I hate making icons. I'm not a designer. I can tell good design from bad, but I can't produce it. For my first two apps, I spent more time on icons than on actual features. That's insane.

Then I found Iconis. It generates Apple-quality app icons from a single image. You pick a background, it handles the gradient, the shadow, the rounded corners, the metadata export. I went from spending 4 hours on icons to spending 4 minutes.

I wish I was exaggerating. Iconis alone probably accelerated my last three launches by a week each. Not because icons take a week to make, but because the dread of making them would stop me from starting the project at all.

Screenshots That Don't Embarrass You

App Store screenshots are the worst. You've built something cool, tested it, polished it, and then you have to create 6 different screenshots in 3 different sizes with text overlays and device frames. It's pure drudgery.

Devspera's screenshot tool handles this. Upload your screenshots, pick a template, adjust the text. Done. I use it for every launch now and it saves me a full afternoon each time.

Shipping Without Breaking Yourself

The hardest part of solo development isn't technical. It's maintaining momentum when there's no team to hold you accountable.

I use Prod Me for this. It's a persistent reminder app — not like your standard notification that fires once and disappears into the void. Prod Me keeps buzzing every 5 minutes until you actually mark the task done. It sounds annoying, and it is. That's the point.

I set reminders for deployment steps I always forget:

• Update the version number
• Push the build to TestFlight
• Submit for review
• Update the website

Each one fires sequentially. I can't snooze my way past them. It's brutal, but it works. Since I started using Prod Me, I haven't missed a single deployment step.

Combined with Nexto for daily task management, my shipping workflow is:

1. Break the launch into Nexto tasks
2. Set Prod Me reminders for critical non-negotiables
3. Execute in sequence
4. Ship

What I'd Do Differently

If I could go back and tell myself one thing before building the first app, it'd be this: stop romanticizing the process.

You don't need the perfect development environment. You don't need to write your own authentication system. You don't need to wait until you're "ready." You need a consistent workflow and the willingness to ship something imperfect.

The tools I mentioned didn't make me a better developer. They made me a more consistent one. They removed friction points that were killing my momentum. When you're building alone, momentum is everything.

What's Your Shipping Workflow?

I'm genuinely curious — what does your solo development workflow look like? What tools do you rely on that aren't the obvious ones?

If you're struggling with a specific part of the process — icons, screenshots, task management, code organization — try one of the Devspera tools. They were built by someone who faced exactly those struggles and got tired of accepting them.

Start with ZeroPad. It's free, takes 2 seconds to install, and might change how you think about your new tab.