The Honest Ledger

• Day 301

  Final month: the honest year-in-review, no spin. What shipped, what died, the real numbers, what I'd do differently. If you've followed since day 1, you earned the unvarnished version. Building in public means the ending's public too.

• Day 302

  First admission: I built twelve apps and should have built four. The portfolio was a search strategy, and it worked — but the tax was attention split twelve ways. I learned which apps want to exist. Next year I feed those. Now I concentrate the chips.

• Day 303

  What shipped: [apps that hit the store]. Internal-only: [list]. Killed: [list]. A portfolio year isn't measured by how many you launched — it's measured by how honestly you culled. Killing your own app is a skill I got better at. Sunk cost is not a strategy.

• Day 304

  The real numbers, no brackets left unfilled: [N] total users, [N] paying, [N] MRR, [N] daily active on the best app. Whatever they are, they're real and they grew from zero. A small honest number beats a big fake one. This is the true scoreboard.

• Day 305

  The biggest lesson of 365 days: I'm a strong builder and was a weak distributor, and the second mattered more. If I could restart, I'd spend month 1 on distribution, not month 9. Build and sell from day one or you build a beautiful thing nobody finds.

• Day 306

  🧵 Thread: everything a year of building 12 apps solo taught me.

  • Build machines, not artifacts. Shared core, generators, one pipeline — leverage carries a fleet.
  • Distribution is a co-equal discipline from day 1, not a phase after building.
  • Verification beats trust. The agent (and you) will file green checks over a fire. Run the gate.
  • A payment from a stranger is worth 1,000 downloads. It's a verdict, not a vanity metric.
  • Honest-about-early is your best content. Nobody roots for a fake hockey stick.
  • Twelve bets found the signal. Concentration cashes it.
• Day 307

  On the agent workflow, a year in: it's real leverage, and it's not magic. It multiplied my output and never once made a decision worth making. The taste, the culls, catching false-greens — that stayed human. AI made me faster; I chose the right thing.

• Day 308

  What I'd tell a solo dev starting today: your bottleneck is not your stack, framework, or ability to ship. It's whether anyone finds and stays. Optimize for that on day one. The code is the easy 20%. I proved it so you don't have to. Distribution first, always.

• Day 309

  The apps that survived did so for one reason each: an honest answer to "why would someone tell a friend?" The ones I killed didn't. Word of mouth isn't a hack you add later — it's a property the product has or doesn't. Build the reason to share into the thing.

• Day 310

  Verification month aged the best. Every gate, every poison-input test, every "run the command don't trust the summary" — that's why I never shipped a money bug to a real user across a year that included a wallet. Rigor is invisible until the day it saves you.

• Day 311

  Hardest thing I killed: [app]. Well-built, genuinely clever, and nobody wanted it. Killing something good because the market shrugged is harder than killing something broken. Keeping a no-demand app alive out of pride is how solo devs bleed out slowly.

• Day 312

  On money: the first paying stranger changed the psychology of the year. Before it, I was hoping. After it, I had proof the value was real to someone besides me. Everything after the first yes is just finding more like that one. Get to the first payment fast.

• Day 313

  What compounded: the shared core, the CI pipeline, the generative engines, the SEO content. What didn't: any clever feature I was proud of in the moment. Systems compound; features depreciate. I wish I'd spent even more of the year on the machines.

• Day 314

  A distribution win I underrated: SEO content I wrote in month 9 is still bringing in users in month 12, for free, while I sleep. It paid back slowly and then kept paying. The compounding channels are the ones you start too late and thank yourself for later.

• Day 315

  Biggest strategic error, plainly: I treated "build" and "distribute" as sequential when they're parallel. You don't finish building and then start selling. You do both, every week, from the start. Half the apps and ten times the users if I'd known that.

• Day 316

  What building in public did for me: it forced honesty. You can lie to yourself about traction in private; harder when you posted "0 users" to an audience. The public ledger kept my self-assessment calibrated. Accountability is a feature of publishing, not a side effect.

• Day 317

  On the twelve-app bet, final verdict: right to start wide, wrong to stay wide. The portfolio was the right way to find what works and the wrong way to scale it. Explore with breadth, exploit with focus. I nailed the explore and was slow to switch.

• Day 318

  My most technically proud app (Aether) isn't the one with the most users (probably Cipher). That gap taught me everything: technical excellence and user demand are different axes, and I optimized the wrong one too long. Build what people want at the quality it needs.

• Day 319

  A quiet thing that mattered: shipping daily, even tiny, for a year. Not "consistency is magic" — the product had to be good — but a good product shipped consistently finds its people slowly. The compounding is real, just slower than the posters promise.

• Day 320

  What the knowledge graphs taught the fleet: structure your data around the questions, ground your AI in facts, and it stops lying. GraphRAG, provenance, LLM-proposes-code-disposes — the most portable engineering idea of the year. I'll put it in everything next.

• Day 321

  On self-hosting (Huddle): building for the "own your data" crowd is a great product thesis and a brutal distribution one — the people who most want control are the hardest to reach and slowest to switch. Right product, hard market. I'd market it completely differently.

• Day 322

  The verification-is-the-product idea generalized by year's end: I verify metrics before I tweet them, AI nutrition claims before showing them, puzzles before shipping them. "Prove it, don't assert it" became the whole studio's operating principle.

• Day 323

  Honest financial reality: [N] MRR does not yet pay for a solo dev's life, let alone a studio. This year proved the machine works — build, ship, verify, distribute — not that it pays rent. Year two is volume through a proven pipeline. I built the engine; now I feed it.

• Day 324

  🧵 Thread: what I'd keep and what I'd change after a year.

  • Keep: the shared core. Every reusable hour paid back tenfold.
  • Keep: the verification spine. Never shipped a money bug to a real user.
  • Keep: no fake numbers, ever. Trust compounds slower than lies but doesn't crash.
  • Change: start distribution on day 1, not month 9.
  • Change: build four apps, not twelve. Explore wide, then commit hard.
• Day 325

  On burnout, honestly: twelve apps solo for a year is a lot, and what saved me was the machines doing the repetitive work so my energy went to decisions and taste. Leverage isn't just output — it's not grinding into paste on plumbing. Sustainable beats heroic.

• Day 326

  The community around these posts became an unexpected asset: early testers, honest feedback, first users, people who flagged a wrong take. Building in public builds an audience while you build the product. The posts were distribution in parallel, not overhead.

• Day 327

  A failure I haven't mentioned: I under-invested in onboarding all year. Great apps, lossy first-run experiences. The activation gap cost me more users than any channel could refill. Next year onboarding is a first-class feature. The first 60 seconds decide the rest.

• Day 328

  What surprised me most: the apps I thought would win mostly didn't, and one I nearly cut early showed the most life. You can't predict which bet pays off — you place cheap bets, watch honestly, feed what moves. Humility about your own predictions is an advantage.

• Day 329

  On doing it clean: every generated puzzle, every graph fact, every piece of content this year was computed or composed originally, never scraped. More work, zero liability, and I'd do it again without hesitating. The honest path compounds; the shortcut comes due.

• Day 330

  The metrics that actually predicted survival: day-7 retention and "would you tell a friend," not downloads or MRR. The leading indicators were about keeping and spreading, not getting and charging. I watched the lagging metrics too long. Measure the leading edge.

• Day 331

  The most valuable artifact from this year isn't any app — it's the pipeline: idea to shipped, tested, monetized, distributable app faster than almost anyone solo. The apps are outputs. The pipeline is the asset. The factory outlasts any product.

• Day 332

  What I got right early and doubted later but shouldn't have: the shared core. Every hour spent making it reusable paid back tenfold. When you're one person, leverage is the difference between twelve apps and two. Doubt everything except your leverage. Reuse ruthlessly.

• Day 333

  On the "solo founder can't do it all" critique: it's true, and the honest answer is I couldn't. I could build all of it and couldn't market it well. The gap wasn't effort — distribution is a genuine second skill. Year two I level it up or bring in someone who has it.

• Day 334

  A lesson for anyone using AI agents to build: the model will confidently tell you it's done. It's your job, permanently, to be the one who checks. My whole value over "just prompt an AI" was taste, verification, and knowing what not to build. The job moved up the stack.

• Day 335

  What the wallet taught me about product responsibility: when you hold someone's money or data, "move fast and break things" is out. Some products earn the right to iterate loosely; some demand paranoia. Matching rigor to blast radius is senior judgment.

• Day 336

  Honest take on "building in public": it kept me accountable, built a small audience, generated real feedback. It did not magically solve distribution — a public build with no PMF is just a transparent struggle. It's a multiplier on a good product, not a substitute.

• Day 337

  The apps I'm carrying into year two: [survivors]. Chosen on evidence — retention, referral, revenue, genuine pull — not on which I love most. Separating "I like building this" from "the market wants this" was the hardest and most important discipline of the year.

• Day 338

  What I'd tell day-1 me: "Build fewer, sell sooner, verify everything, start distribution before you feel ready." The rest — architecture, agents, graphs — I mostly got right. The sequencing is what I'd rewrite. Do the scary go-to-market work first.

• Day 339

  On the numbers being small: I won't be embarrassed by an honest small number that grew from zero. Every large number was a small number someone didn't quit on. Founders who fake big numbers early borrow against a trust they'll repay. I'd rather compound from the truth.

• Day 340

  The generative engines, the knowledge graphs, the verification spine — the deepest engineering of the year — all carry forward and keep paying. Depth compounds. The shallow features I rushed are mostly forgotten. If I had the year back I'd go deeper on fewer things.

• Day 341

  A distribution experiment that worked: leading with a 15-second clip of the app doing its one impressive thing beat every wall of feature copy. People watch outcomes, not read benefits. I'll open with the demo, not the pitch, forever. Motion sells; prose explains.

• Day 342

  On money and mission: I want these apps to pay for themselves so I can keep building them honestly — no data-selling, no dark patterns, no VC pressure to juice numbers. Sustainable-and-honest is the goal. A profitable small studio that respects users is enough.

• Day 343

  The retro on tools: RevenueCat, Matrix, LiveKit, the agent loop — I adopted every "solved problem" and built only the differentiated 20%. That's why one person shipped this much. Reinventing solved wheels is how solo devs run out of year. Adopt, don't rebuild.

• Day 344

  What scared me this year: shipping a wallet. Holding people's keys is a responsibility I didn't take lightly; Aether's paranoid pipeline reflects that. If it scares you appropriately, you'll build it carefully. The fear was a feature. Respect the products that can hurt.

• Day 345

  On consistency, honestly: I didn't post daily because "consistency is magic." I posted because a public commitment kept me building when motivation dipped, and the machines kept the output real when energy was low. Build systems that don't need you to be inspired.

• Day 346

  The clearest signal of the year: apps with a built-in reason to share (Cipher's result, Aether's scam-catch) grew organically; the ones without it needed me to push every user. Distribution designed into the product is the only kind that scales for a solo dev.

• Day 347

  What year two looks like: concentrate on the survivors, put distribution level with building from week one, get onboarding right, push winners toward revenue that sustains the studio. Fewer apps, deeper, louder. The search phase is over; the commit phase begins.

• Day 348

  A thank-you I mean: to everyone who followed a solo dev post "0 users" for months and stuck around. You were the first distribution channel, testers, honest critics. Building in public only works because someone's watching. You made the ledger true. Thank you.

• Day 349

  The counterintuitive lesson: my worst enemy all year wasn't a competitor or a bug — it was my own comfort. I kept retreating to building (good at it) not distributing (not). Growth lived in the uncomfortable direction. Run toward what you're bad at.

• Day 350

  Day 350. The honest state of Erebos Lab: a proven build-and-ship machine, a handful of apps with real (small) traction, [N] MRR, zero fake numbers, and a founder who finally understands the job. Not a triumph, not a failure — a foundation. Year two runs it hard.

• Day 351

  On whether it was worth it: unequivocally yes, and not because the numbers are big — they're not. It's worth it because I now know exactly what I'm good at, what I'm not, and what to fix. A year of honest data about yourself beats a year of comfortable delusion.

• Day 352

  The failure I'll carry forward as fuel: I could've had a tenth of the apps and ten times the users. Not a regret, a thesis for year two. Depth over breadth. Distribution over more features. Fewer, better, louder. Learning the lesson was worth the tuition.

• Day 353

  For builders earlier than me: ship the thing, but talk to a user the same day. Don't spend a year proving you can build before you check if anyone cares. The market tells you the truth faster than your conviction. Get to the truth early. It's kinder than hope.

• Day 354

  On AI and solo building: the leverage is real and growing, and it raises the floor, not the ceiling. Everyone can build now, so building isn't the moat. Taste, distribution, trust, and knowing what to build are the moat. The scarce skill moved. Invest where it went.

• Day 355

  What I'm keeping from the verification obsession: the habit of asking "how would I know this is actually true?" about every claim — my metrics, my AI's outputs, my own sense of progress. That question is the most valuable thing I built all year, and it lives in no repo.

• Day 356

  The studio thesis, revised: "build many small honest apps, learn on the cheap ones, fund the ambitious ones" was almost right. The fix: learn on the cheap ones fast, then concentrate hard. The portfolio is a telescope, not a home. Find the star, then fly there.

• Day 357

  A number I'm proud of that isn't growth: [N] consecutive days shipping something, [N] daily puzzles with zero broken dailies, zero fabricated metrics, zero money bugs shipped. Reliability and honesty are achievements too. Not everything that counts is a user count.

• Day 358

  On starting over knowing what I know: I'd build the same machines and make different choices about what to point them at and when to sell. The engineering was rarely the mistake. The strategy and sequencing were. Some lessons only install by running the program.

• Day 359

  What building in public cost me: some ego, posting a flat-zero graph while others posted hockey sticks. What it bought me: a calibrated view of reality and an audience that trusts me because I posted the zero. Honesty is cheap to post and expensive to fake.

• Day 360

  Five days left. The core truth of 365 days, plainly: a solo dev with good machines can build almost anything, and building was never the hard part. Distribution is the boss, always was, and I finally know how to fight it. That clarity is the year's real product.

• Day 361

  To the version of you thinking about starting: the tools have never been better and building has never been easier, so the bar moved to everything around the building. Start the distribution muscle on day one. I didn't. Learn from my expensive, public, honest mistake.

• Day 362

  What's next for Erebos Lab: fewer apps, deeper, with distribution and building as equal partners from the first commit. The survivors get everything; the rest served as scouts. Year two isn't about proving I can build. That's done. It's about getting it into the world.

• Day 363

  A promise for whatever comes next: same rules. No fake numbers, no scraped content, no dark patterns, no data-selling, no money bugs, no trusting a green check I didn't verify. The apps will change. The integrity won't. The one thing worth keeping consistent.

• Day 364

  Tomorrow is day 365 and I want to be clear what this was: not a success story, not a cautionary tale — a ledger. An honest year of a solo dev building twelve apps in public — numbers real, lessons earned. The most useful thing I made might be the record of it.

• Day 365

  Day 365. One dev, twelve apps, one year, public, no lies. Proved I can build. Distribution is the boss. I have [N] users, [N] paying, [N] MRR — small, real, from zero. Not the finish — proof the machine runs. Year two: point it at the world. Thank you. — @caelum0x42

← All build-log months