Building in public means sharing your process as you build — not just the finished product. You share the wins, the bugs, the pivots, the revenue numbers, the mistakes. You do it consistently, in public, in real time.

It sounds vulnerable. That's because it is. It's also one of the most effective growth strategies available to indie developers right now — and it costs nothing but consistency.

This guide covers what build-in-public actually means, why it works, how to start, what to share, and how to sustain it without it consuming your life.

Why build in public at all?

The core mechanism is simple: trust. When someone follows your building process for months and then you launch — they're not cold users. They've watched you work. They've seen the problems you ran into. They already believe you can ship.

Patrick Collison built Stripe in public. Pieter Levels built Nomad List with a public revenue counter. Levels went from zero to $1M+ ARR and publicly attributed a significant part of his growth to the transparency itself. More recently, dozens of indie hackers have built audiences of 10,000–100,000 people primarily by sharing their building process.

The pattern is consistent: transparency creates compounding trust, compounding trust creates users, users create revenue.

What counts as building in public?

A lot of founders think they need to share revenue numbers or deep technical decisions to "really" be building in public. You don't. Building in public is any of the following:

  • Posting a weekly update on what you shipped

  • Sharing a bug you spent 6 hours debugging (and how you fixed it)

  • Showing your feature planning process before you build

  • Being honest about what didn't work and why you changed direction

  • Sharing user feedback you received (positive or negative)

  • Posting your metrics — users, revenue, churn, conversion — even when they're small

  • Documenting decisions: why you chose this stack, this pricing, this name

The content doesn't need to be dramatic. The consistency is the thing.

How to actually start

Step 1: Pick your primary platform. One is enough to start. X (Twitter) has the largest build-in-public community. LinkedIn reaches a more professional audience. Bluesky is growing among technical users. Forg.to lets you post once and distribute to all three simultaneously — which is the most practical choice if you're starting from zero and don't want platform management to be a second job.

Step 2: Set a minimum posting frequency you can actually keep. Weekly is better than daily if daily will burn you out in three weeks. The worst thing you can do is start with a burst and disappear. Readers forgive slowdowns; they don't forgive silence.

Step 3: Define what you're building. Before your first post, write a "start here" post: what the product is, who it's for, where it is now, and what you're trying to achieve. This becomes the anchor for everything you post afterward.

Step 4: Connect your building tools. If you're using GitHub, connect it to your forg.to profile. Your commits and PRs become a built-in activity log. Your LeetCode streak, your articles, your project updates — all of it streams into one place. This means you're always "building in public" even when you forget to post.

What to share (and what to skip)

Share:

  • Specific wins with numbers: "Hit 100 users today, 3 months after launch"

  • Honest failures: "Spent 2 weeks on a feature nobody asked for. Cutting it."

  • Process posts: "Here's exactly how I'm thinking about pricing"

  • Milestone posts: first user, first dollar, first 100 users

  • Question posts: "Stuck on X. Has anyone dealt with this?"

Skip:

  • Vague inspiration ("consistency is key 🔑")

  • Progress for progress's sake ("worked on the app today")

  • Anything you'd be embarrassed if a competitor read

The most engaging build-in-public content is specific and honest. Generalities don't create conversations.

Sustaining it

The mistake most builders make is treating build-in-public as a marketing task separate from their building. Then it becomes a chore and they stop.

The better frame: your building process is happening anyway. You just need to make it visible. A GitHub commit message that would normally disappear can become a post. A user complaint you addressed becomes a story. A decision you made about your pricing strategy is already in your head — it takes 10 minutes to make it public.

Tools like forg.to's Creator Studio exist specifically for this. You write one update — and it distributes everywhere. You connect GitHub — and your commits automatically become post drafts you can publish or discard in two clicks.

The less friction between your building and your posting, the more sustainable build-in-public becomes.

The build-in-public community on forg.to

Forg.to has a community of 300+ builders doing exactly this. Every week there's a Launchpad where you can launch your product in front of other builders for real feedback and not upvote farming, actual critique from people who build things.

If you want to start building in public and you want a place where your updates actually live permanently (rather than getting buried in a feed), forg.to is worth setting up: forg.to

Your profile lives at forg.to/@yourname. Every post you make, every project you add, every update you write — it stays there, searchable, permanent, and tied to your identity as a builder.

That's the point.