Introduction

This handbook serves as a guide to turn ideas into products people use. It’s for engineers, designers, and solo founders who can build but want steady momentum, early validation, and clear feedback. The approach stays simple on purpose: small steps, fast learning, steady progress.

It comes from over 15 years shipping software and more than 60 side projects. Most stopped at prototype. The pattern was the same: build, polish, launch quietly, see little usage, move on. Skill wasn’t the problem. Process, feedback, and momentum were.

TenK 6 breaks that pattern. It’s a simple loop: focus effort, get real feedback, keep building. No over‑engineering. No quiet launches.

The TenK 6 Loop

List: Write a small set of concrete ideas.
Pick: Choose exactly one to do next.
Ship: Deliver the smallest testable slice.
Ask: Put it in front of real people.
Measure: Track a few clear signals.
Share: Say what happened and what’s next.

Repeat. Keep cycles short so the next step stays obvious. The goal isn’t more code. It’s clear signals and steady momentum.

Why this matters: most indie projects fail from weak user contact, not lack of skill. TenK 6 makes user contact part of every cycle.

Notes on the Steps

List: Capture a few specific ideas you can do in days.
Pick: Commit to one. Cut context switching. Set a finish line.
Ship: Release the smallest version that gets real feedback. Skip gold‑plating.
Ask: Watch what people do. Don’t pitch. Look for behavior, not opinions.
Measure: Choose a few signals up front. Prefer sharper tests over bigger scope.
Share: Note what happened and what changes next. Keep it brief and honest.

Principles

Ship beats polish: visible progress > invisible perfection.
Small boxes force choices: tight time and scope surface priorities.
Test conviction: treat enthusiasm as a hypothesis.
Share often: updates reduce isolation and invite help.

Who It’s For

For independent builders and small teams who want a simple operating rhythm. It fits side projects with limited hours and early product phases where demand is the main risk.

How to Use This Handbook

Read once to see the loop.
Pick a small idea and run one cycle end to end.
Note the plan, changes, and what you learned.
Share a short update at the end of each cycle.
Repeat. Tune scope to keep cadence.

What to Expect

Early cycles bring small wins and strong learning. Over time, shipping, asking, and measuring cut guesswork and focus effort on what works. Retire weak ideas early to save time for the ones with traction.

Indie10k

Indie10k came from using these principles again and again. Aim for sustainability, not perfection. TenK 6 is the operating rhythm behind that work. This handbook distills it so you can use it in any domain or stack.

Closing

If you start strong and abandon quietly, you’re not alone. Cadence and process separate code that piles up from products that grow. TenK 6 gives you a small, dependable loop for both.

By the end, you’ll plan and run TenK 6 cycles, judge outcomes with evidence, and decide when to persevere, adapt, or stop. Move steadily toward products people value.

Chapter 1: Why Indie Projects Fail

Indie projects don’t fail because you can’t code. They fail because ideas turn into domains, repos, and prototypes—but never turn into products people use. You pour weeks into “almost there,” polish the edges, then lose steam. Someone asks how it’s going. You change the subject.

You’re not alone. Most solo builders carry a quiet archive of half-finished work. Different ideas, same ending.

The Pattern That Drains You

The loop looks familiar:

Build → Polish → Nobody uses it → Move on → Repeat.

Zoom in and it’s even clearer:

The spark: a late-night idea feels obvious and exciting.
The build: you sprint for a week and carve out half a product.
The polish: you sweat the logo, rethink the architecture, chase pixel perfection.
The silence: you launch softly. Crickets.
The abandon: you convince yourself it wasn’t the right idea and switch tracks.

Do this a few times and you train yourself to start strong and finish nowhere. You get faster at beginnings and slower at endings. Motivation dips. You think the answer is a better idea. It isn’t.

Three Traps

You don’t stall from lack of talent. You stall because you hit predictable traps.

Overbuilding shows up first. You reach for a perfect architecture when a cardboard mock would prove the point. You design a system that can scale to a million users when you haven’t shown one person cares. Scope feels like progress, but it hides the risk you should face now.

Hiding follows. You keep the work private because a quiet room feels safer than a blunt “no.” You plan to show people “when it’s ready.” It never is. Secrecy blocks the small conversations that uncover simple wins and obvious cuts.

Then momentum fades. Without short feedback loops, every step gets heavier. You pause for a week, then two. Picking the work back up feels like lifting a cold barbell. Projects slow until they stop.

Together, these traps produce one outcome: you start a lot and finish little. Effort spreads thin. Evidence stays scarce.

The Real Problem

For years I blamed the idea, the market, the timing. I told myself I needed more time. Or better marketing. Or a cleaner stack. After enough false starts, the truth landed: the ideas weren’t the problem. The process was.

I had adrenaline for starts and no rhythm for middles. I didn’t collect evidence. I didn’t close loops. I couldn’t point to proof that the last week moved me forward.

Why Big Playbooks Don’t Fit

Most startup advice assumes teams, budgets, and long timelines. You don’t have those. You have evenings, weekends, and a brain that wants to build. A forty‑slide funnel deck won’t help you choose what to do tonight. You need a move you can make in hours and a way to tell if it mattered.

What Works Instead

Replace guesswork with a small loop you can run on repeat. Focus on six actions that force contact with reality. Write options. Choose one. Ship a thin slice. Ask real people. Measure a single signal. Share what happened. Each cycle ends with proof you can keep.

That loop is TenK 6. It won’t make ideas easy. It will make progress visible. And once progress shows up on the page—screenshots, numbers, links—momentum follows.

In the next chapter, you’ll see how the loop works and how to run your first pass without burning a month.

Chapter 3: The TenK 6 Methodology

TenK 6 is a small operating rhythm. It helps you decide what to do next and then prove that it mattered. You run short cycles. Each one ends with evidence you can point to: a screenshot, a link, a number. Over time, that evidence stacks into momentum.

Why This Loop

You don’t stall because you lack skill. You stall when next steps blur. TenK 6 clears the path. It moves you from intention to proof in six moves. It works at any pace—an evening after work or a focused weekend—because the steps stay small and clear. The loop reduces cognitive load: fewer choices, fewer resets, and more time with hands on the right work.

Who It’s For

This loop fits indie founders who want structure without ceremony, solo builders who want fewer decisions and more progress, and small teams that want accountability without a calendar full of meetings. It adapts to early idea hunting and later optimization because the same six steps work whether you’re at zero users or shipping polish to thousands.

Step 1: List

Start wide. Write five concrete options you could attempt next. Force breadth before focus. Don’t justify them yet. One sentence per option is enough. The goal is to see choices on the same page so you can choose with a cooler head. Listing protects you from anchoring on the first shiny thing and reveals alternatives you’d otherwise ignore.

Example: “Add a pricing page,” “Record a 2‑minute demo,” “Interview three churned users,” “Test a landing page for feature X,” “Email five prospects with a short offer.”

Step 2: Pick

Choose one. Commit for a single loop. Say “not now” to the rest. You trade optionality for momentum on purpose. A clear pick removes second‑guessing and protects your attention for the next few days. Most decisions are reversible at this scale; choosing quickly costs less than spinning in place.

Good picks feel doable in a week and a little uncomfortable. If it scares you because someone might see it, you’re probably on the right track.

Step 3: Ship

Put a small, testable slice in the world. Prefer ugly and live over perfect and hidden. A thin page, a rough prototype, a basic email—anything a real person can touch. Shipping pulls your idea out of your head and into reality where it can meet feedback. Fake doors and manual workflows are valid—speed to signal beats engineering completeness in early loops.

Ask yourself: “What can I launch in 48 hours that proves this exists?” Then cut that in half.

Step 4: Ask

Get feedback from real people. Post. DM. Email. Show it to someone who might care and watch what they do. Don’t fish for praise. Listen for behavior—clicks, replies, specific questions. Curiosity teaches more than compliments. Ask short, concrete questions: “What did you expect here?” “What would you try instead?”

A simple line works: “I’m testing this—curious if it solves your problem.”

Step 5: Measure

Track one useful signal. Define it up front so you don’t move the goalposts later. It might be sign‑ups, replies, a click‑through, or a paid trial. Look at what actually happened, not what you hoped would happen. Choose a metric that matches the loop’s purpose—activation for onboarding work, revenue for pricing trials, reach for distribution.

One number is enough for a loop. You can add nuance later.

Tell the story. Say what you tried, what changed, and what you’ll do next. Sharing builds accountability and draws in people who care about the same problems. It also gives future‑you a record of decisions and results. A simple structure works: context → action → evidence → next step.

Keep it short. A screenshot and three sentences beat a silent masterpiece.

Principles That Keep It Honest

Evidence beats intuition. Count proof, not plans. Move one step at a time and finish with evidence before moving on. Keep pace flexible—some weeks sprint, some weeks crawl—but don’t let the loop stop. Reflect weekly so learning sticks and informs the next pick.

Tracks to Aim Your Loop

You can point the same six steps at different bottlenecks. When you need demand, run a Validate loop to prove people care about the problem. When you need attention, run a Distribute loop to reach more of the right people. When you need revenue, run a Monetize loop to convert attention into dollars. When you need durability, run a Retain loop to help customers stick around. Switch aims when your constraint moves; don’t outrun acquisition if activation still fails.

You don’t change the loop. You change the aim.

What Makes It Work

TenK 6 doesn’t predict the future. It shortens it. Each loop expands your options, forces a decision, creates evidence, and builds accountability. The compounding effect turns scattered effort into steady growth. Proof stacks; decisions get easier; the next step gets clearer.

In the next chapter, you’ll start where every loop begins: List.

Chapter 4: The First Step — List

If TenK 6 is a map, List is the trailhead. It looks small—almost too simple—but it sets your direction. Start wide and you avoid false certainty. Start narrow and you risk months on the wrong bet.

Why List Matters

Most builders fall for the first shiny idea. You picture the UI, feel the dopamine hit, and dive into code. That rush is real, but it isn’t reliable. Listing five ideas breaks the spell. It pulls you back to options. It reminds you that ideas are cheap; evidence is not.

When you put five ideas on the same page, you stop romanticizing a favorite and you start comparing tradeoffs. Patterns surface. A theme might show up across options—like “help people start” or “cut setup time.” You feel freer to test instead of defend because you haven’t sworn loyalty to one path yet. You also spot “adjacent possibles”—small variants that improve the idea without inflating scope.

That’s the point. List separates exploring from committing. Explore first. Commit next.

A Real First List

On a slow Tuesday, I stared at four dull options. Here’s one that kicked off a real loop:

Sudoku game.
YouTube content idea generator.
Simple video editor (CapCut/Canva alternative).
Growth coach for indie builders.
A cross word game.

Number 4 became Indie10k. The win wasn’t the selection. The win was forcing five options onto the page before choosing.

How to List Well

Keep it light. One sentence per idea. Skip specs and diagrams. You’re capturing candidates, not committing to projects. Timebox yourself to fifteen minutes so momentum stays high. If an idea scares you because real people might see it, include it. Post the list somewhere you’ll see it again—a notes app, a doc, or a small public post if you want accountability. If you’re stuck, write one “anti‑idea” (what you would never build) to jog new angles.

You don’t need a framework to list. You need a timer and a place to type.

Common Missteps

Researching TAM before you list drags you into analysis when you need options. Treating ideas like commitments loads emotion onto a step that should feel light. Stopping at one because it “feels right” turns a guess into a plan. Write all five. You can still pick the first one—after you see it next to four others. The act of writing options is the work; good picks come from seeing choices clearly.

A Simple Prompt

If you get stuck, use this: “What five things could I ship in one week that would create a real signal?” Aim for sign‑ups, replies, clicks, or a person who says, “I’d pay for that.” Not a prototype museum—signals. Prefer ideas where you can press “publish” rather than “perfect.”

Micro-Exercise

Before you close your laptop tonight, write five ideas you could ship in one week. No edits. No research. Just write. Tomorrow, you’ll pick one and move.

List kicks the loop into motion. Pick keeps it rolling.

From List To Pick

When you finish the list, step away for ten minutes. Read it once without editing. Ask: which option would teach me the most this week? Circle it. That question keeps you from choosing what flatters your skill and steers you toward what advances the project.

Chapter 5: The Hardest Part — Pick

If List gives you freedom, Pick gives you movement. Commitment feels scary because it shuts doors, but for one loop, that’s the point. You cut options so momentum has room to build.

Most builders don’t actually pick. We hedge. We juggle. We say, “I’ll explore both in parallel and see which one sticks.” Neither sticks. Splitting attention keeps you from finishing anything you can measure.

Why Pick Matters

Momentum dies in indecision. The longer you hold multiple ideas, the more reasons you invent to delay: maybe the other idea is better; maybe you should validate more; maybe you can tinker with both. TenK 6 doesn’t reward tinkering. It rewards loops. Loops only spin when you pick a wheel. Remember: at this scale, almost every choice is reversible. The cost of waiting is higher than the cost of a small miss.

The rule is simple: one loop, one idea. Not three. Not two. One.

From Five to One

Remember the first list: sudoku game, YouTube idea generator, simple video editor, growth coach, and a forgettable fifth. If I hadn’t picked, I’d be half‑building a sudoku grid while daydreaming about YouTube tools.

I picked “growth coach” because it scared me. Games and tools let me hide. A coach meant showing up, asking people questions, and putting my name on the work. The discomfort was a signal. That path became Indie10k. The feeling to watch for isn’t certainty—it’s energy. If an idea pulls you forward and asks you to show up, it’s strong enough for one loop.

How to Pick (Fast and Well)

Decide with your gut, not a spreadsheet. This isn’t due diligence; it’s a one‑loop bet. Choose the option that excites you or spooks you a little—it likely matters. Timebox the decision to twenty‑four hours after you list. If you’re still agonizing on day three, you’re procrastinating. Use constraints to break ties: which idea can you ship a version of in seven days? Pick that one. Write your pick down in a sentence so you know what you just committed to.

Pitfalls to Avoid

Analysis paralysis feels productive and kills momentum. The more criteria you invent—TAM, CAC, saturation—the less likely you’ll ship. Fake picking sounds like “I’ll start with A but keep exploring B.” That’s hedging, not choosing. Forever dreaming hides fear under the word “readiness.” If you’ve carried an idea for two years and still haven’t built it, pick it for one loop or let it go. Sunk cost doesn’t apply here; you owe the future loop a clean start.

Micro‑Exercise

Look at your five. Circle one. Commit to a full TenK 6 loop on that idea—even if it fails. Picking doesn’t mean “forever.” It means this loop. After six steps, you get to list again. Put your pick where you’ll see it every day; protect it from drive‑by ideas until the loop ends.

The cost of picking wrong is one loop. The cost of never picking is months lost to maybes.

Decision Heuristics That Help

Use proximity: pick the idea closest to a real user conversation you can have this week. Use friction: if two options tie, choose the one that forces you to talk to someone. Use reach: favor moves that unlock more options next week (e.g., a demo video you can reuse in emails).

If You Regret Your Pick

Don’t switch mid‑loop. Finish the smallest possible version of what you chose, collect one signal, and close the loop. Then list again with your new information. Switching early teaches you to quit before evidence arrives.

Public Commitment (Optional)

If you struggle to stick with a pick, post a one‑liner: “This week I’m shipping X; I’ll share results Friday.” A tiny public promise keeps the loop moving when your mood dips mid‑week.

Chapter 6: The Momentum Engine — Ship

Picking is a decision. Shipping is proof. Until you ship, everything else is theory. Ideas stay safe in your head. Boards and docs feel organized. None of that creates momentum. Momentum arrives the moment someone outside your brain can touch your work.

Why Ship Matters

Shipping isn’t about polish. It’s about forcing reality to collide with your idea. Without shipping, you can’t ask real users. Without users, you can’t measure anything. Without data, you can’t share a story that resonates. Ship is the bridge between dreaming and learning.

Day 1 Indie10k

After I picked “growth coach,” I didn’t design a brand system, architect microservices, or perfect onboarding. I grabbed a Next.js boilerplate, pushed to Vercel on commit one, wrote a landing page with a headline and fake login, and hit deploy. It wasn’t pretty or scalable. It was alive. Alive beats perfect every time. Day two, the fake login became a simple form that emailed me so I could reply manually—messy, fast, and good enough to learn.

Ship Fast Without Hating It

Define a one‑sentence deliverable: “A page where people can sign up and see a dashboard with one fake number.” Kill scope aggressively. If it feels like an MVP, cut it in half. Then cut it again. Timebox shipping to seven days max—ideally one to three. The longer you take, the more you’ll over‑engineer. Automate nothing. If you can fake it behind the scenes, do it. Manual is allowed (and encouraged) in your first loop. A fake door (button that says “coming soon”) is better than a month of backend work.

Pitfalls to Avoid

“Just one more feature” turns a deadline into a checklist. Polish addiction keeps you in CSS while users wait. Secret shipping skips the whole loop; if you build for months in stealth, you lose the only feedback that matters.

Micro‑Exercise

Take your picked idea. Write: “What’s the smallest thing I can put online that proves this exists?” Give yourself forty‑eight hours to launch it—ugly, incomplete, even embarrassing.

If you don’t ship, you’re not in the loop.

Scope Boxes for Different Products

SaaS: a landing page, a signup form, and one screen with one fake metric. Mobile: a tappable prototype with one flow and TestFlight or APK link. Content product: a one‑page guide and an email capture. Service: a Calendly link and a two‑paragraph offer. If you can show it or schedule it, you can ship it.

When You Get Blocked

Shrink the deliverable until no part depends on a complex decision. Replace integrations with screenshots or Looms. Replace database writes with a Google Form. Replace auth with a single‑use link. If a task takes more than a day, you’re solving two problems—cut one.

Chapter 7: The Scariest Step — Ask

Shipping feels bold. Asking feels personal. Shipping lets you hide behind code. Asking puts your work—and, by extension, you—in front of real people. You risk silence, criticism, or rejection. That risk is where learning lives.

If you don’t ask, you don’t learn.

Why Ask Matters

Most indie projects die not because the product is bad, but because the builder never asks anyone to use it. They wait for “organic discovery” and hope users appear on their own. Asking cuts through that fantasy. It tests whether anyone cares enough to click, sign up, or even reply. It shows whether the problem you’re solving sits on their radar.

Without asking, you’re journaling in code.

Posting Indie10k

Old me would have shipped Indie10k and waited in silence. New me posted on Indie Hackers, wrote on Product Hunt’s forum, and DMed strangers on Reddit. Not spammy. Not sleazy. Just: “I feel your pain. If I were in your shoes, I would do this. 1. 2. 3. 4. 5. Btw, I built this. Here’s what it does. Curious what you think.” People responded. Some signed up. Some said it was gold. Not everyone loved it—and that was fine. The goal wasn’t approval; it was learning. I kept a short log of quotes and links so patterns stood out.

Ask Without Feeling Gross

Lead with curiosity. Swap “please use my app” for “does this solve your problem?” Go where your people hang out; don’t shout into X if your audience is in a niche Discord. Make it human—share why you built it, not a pitch deck. Small numbers are fine. Ten honest replies beat a thousand empty likes. Ask one follow‑up: “What would you change first?” Specific feedback travels straight to your next ship.

Pitfalls to Avoid

Waiting for perfect postpones learning. “I’ll ask once I add dark mode” is fear in disguise. Broadcasting without engaging turns posts into noise—reply, converse, and listen. Chasing vanity metrics distracts you; five thoughtful replies teach more than a viral spike.

Micro‑Exercise

Take what you shipped and share it with three real humans today—friends, a Discord, Indie Hackers, anywhere. Ask one question: “Would you actually use this?” Don’t argue. Listen for the signal under the noise.

Then move to Measure.

Where To Ask (And How)

Communities: Indie Hackers, r/Entrepreneur, niche subreddits, and Discords tied to your problem space. Direct: past colleagues, newsletter subscribers, people who tweeted about the pain. Local: meetups, coworking spaces, founders’ coffees. Lead with usefulness: “Built a tiny thing that does X—would this save you time?”

Two simple DM variants:

“Hey [name], I’m testing a small [tool/guide] for [problem]. Two minutes to tell me if it’s useful? Link: [url]. If not, no worries.”
“Saw you mention [pain]. I made a scrappy fix—mind a quick look? I’ll owe you one.”

Interviews vs. surveys: interviews reveal stories and hidden steps; surveys scale once you know which questions matter. Start with three short conversations before you blast a form.

Chapter 8: The Honest Mirror — Measure

You shipped. You asked. Now you face what happened. Measure doesn’t care how many nights you coded or how clever the architecture is. It only cares about reality when people touched your work.

Why Measure Matters

Without measuring, you’re guessing. Guessing killed my first sixty‑five projects. Measuring gives you truth: did anyone click, sign up, return, or bounce? Truth stings sometimes. It also points your feet in the right direction.

Indie10k Loops

Loop one: almost nobody stuck. It was heavy and complex. Loop two: better, but still bulky—drop‑off after sign‑up. Loop three: lean enough at last; people completed their first loops. Without measuring, I would have kept polishing that bloated V1. Data forced cuts I wouldn’t have made on instinct.

Measure Without Overcomplicating

Pick one metric per loop. “Number of people who clicked download” is enough. Timebox observation to a week so you don’t chase daily noise. Ignore vanity: pageviews feel nice; completed actions matter. Keep your metric visible—write it where you see it so you don’t drift. Match metric type to step: leading indicators for early loops (clicks), lagging for monetization (payments).

Pitfalls to Avoid

Metric soup lets you rationalize anything. Choose one. Cherry‑picking hides the learning in the ugly bits. Over‑measuring turns a loop into a board meeting. Keep it simple and honest. When numbers are small, look for direction and stories, not statistical certainty.

Micro‑Exercise

Look at what you shipped and ask: “What’s the single most important thing I want to see happen this week?” Write it down. At week’s end, check it. No excuses. No filters. Just the truth.

Measure acts as a compass. Next, you’ll share what you found.

Set a Baseline First

Write the starting number before you ship so you don’t retro‑fit memory. Even “zero sign‑ups” is useful—it makes the first one count.

Reading Small Numbers

In early loops, you won’t have statistical power. Use direction, not precision. Did replies go from zero to three? Did time‑to‑value drop from minutes to seconds? Pair the number with a quote to keep context.

Pivot, Persist, or Pare Back

If the metric moves in the right direction, persist with another loop. If it stays flat and feedback points to a different problem, pivot the aim (switch tracks). If effort balloons, pare back scope until you can see movement again. The measure tells you which lever to pull.

Most builders stop at Measure. They read the data, tweak a feature, and move on quietly. Sharing turns a private loop into compounding momentum. When you share the loop—warts, wins, and what’s next—you attract the right people, build trust, and create surface area for luck. Someone sees a post, DMs you, introduces you, or pays you.

Shipping proves you can build. Asking proves you’re brave. Measuring proves you’re honest. Sharing proves you’re alive.

If you keep your loops private, nobody knows you exist. When you share, you invite others into the journey. People root for progress. Your story becomes your marketing. Over time, that story becomes a moat—hard to copy, built through consistency.

Talking About Indie10k

For years, I thought “real work” lived only in the IDE. With Indie10k, I forced myself to share: build logs on Indie Hackers, cross‑posts on Dev.to and Hashnode, and small updates on X. People didn’t just see a tool; they saw a story. Some became the first users. It wasn’t ads or funnels. It was straightforward storytelling. The cadence mattered more than the channel—showing up weekly built trust.

Be honest. Don’t posture. Share the ugly and the wins. Keep it small—a screenshot, a graph, two sentences. Pick the stage where your audience hangs out: Reddit, Discord, Indie Hackers, X. Teach, don’t pitch. Share what you learned, not just what you built. A simple template helps: why you chose this step, what you shipped, one metric, one learning, what’s next.

Pitfalls to Avoid

Silence cuts off compounding effects. Only sharing wins rings hollow; people relate to stumbles. Vanity updates (“100 likes!”) matter less than real outcomes (“one user paid $10”).

Micro‑Exercise

Write one short post today—anywhere. “I ran a loop. Here’s what happened. Here’s what I learned.” That’s it. No newsletter. No strategy. Just hit publish once.

Sharing isn’t about going viral. It keeps the loop alive so the next one starts with more people in your corner.

With Share, you complete the first TenK 6 cycle: List → Pick → Ship → Ask → Measure → Share. You don’t stop here. You start over. That’s how momentum compounds.

Pick one or two places where your audience gathers and show up weekly. Indie Hackers build logs, a focused subreddit, a Discord channel, or a small newsletter. Cross‑post only when the content fits the room. If a place frowns on links, write a short summary and add the link in a comment.

Anti‑Cringe Tips

Write like you talk. Cut the pitch. Lead with one concrete thing you shipped and one number. Give credit when someone’s feedback shaped your next step. Thank people who replied last time. Consistency beats cleverness.

Repurpose Smartly

Turn a loop update into a tweet, a forum post, and a two‑minute Loom. Same facts, different formats. The point isn’t to be everywhere—it’s to make it easy for the right people to bump into your work.

Chapter 10: Reflect — Turn Loops Into Habits

Finishing a loop isn’t the end. It’s a checkpoint. The power of TenK 6 grows when you pause, reflect, and capture what happened before you spin the next cycle. Without reflection, loops blur together and learning leaks away. Reflection builds a body of evidence—your personal growth archive.

Why Reflection Matters

Founders skip reflection because starting the next thing feels exciting. Reflection multiplies progress. It gives you clarity on what worked and what was noise. Wins fuel confidence. Misses turn into lessons instead of dead ends. Writing it down forces honesty and creates material you can share later.

Half an hour a week can save you months of mistakes.

A Simple Rhythm

At the end of each week—or when you complete a loop—answer five prompts on one page. Keep it conversational; you’re writing for future‑you.

What did you ship? Paste evidence: a screenshot, link, or commit. Who did you ask and what did you learn? Include quotes, screenshots, or even “nobody replied” if that happened. What metric did you track and where did it land—start and end? What surprised you—unexpected feedback, edge cases, small wins? What will you try next? Carry one clear insight into the next loop.

That’s it. Five questions. One page. Then move.

Capture It Well

Keep it light: a notes doc, markdown file, or Indie10k project log works fine. Make it visual—graphs and screenshots beat walls of text. Build a ritual: same time every week—Friday afternoon, Sunday night, or Monday morning. Tag patterns you notice so they’re easy to search later.

Example: Early Indie10k

After loop three:

Shipped a landing page with fake login. Asked on Indie Hackers and got three comments. Tracked sign‑ups: thirty‑seven; return visits: zero. Surprise: the “$10k” framing resonated more than the tool. Next: cut features and lean into the story.

That one page guided everything that followed. Over a month of pages, patterns get loud. You’ll see which channels keep working, which ships stall, and which asks land best. That clarity is worth the half hour.

Micro‑Exercise

Pick a day this week and block thirty minutes. Answer the five prompts. Save the page. Share one insight publicly. You just turned a loop into a habit.

In the next chapter, you’ll see how to aim your loops at the right bottleneck with tracks.

Chapter 11: Growth Tracks — Aim Your Loops

TenK 6 stays the same: six steps, one loop. But not every loop serves the same purpose. Sometimes you need to prove a problem exists. Sometimes you need more attention. Sometimes you need dollars. Sometimes you need to keep the customers you have.

Tracks give each loop a theme. They align your actions to your biggest bottleneck so you don’t ship random features, measure random metrics, or ask random people. Think of them like workout plans: same movements, different focus.

The Four Tracks

Validate Track

Prove people actually want what you’re building. List five problems or hypotheses to test, pick one customer problem, and ship a fast test—a survey, landing page, prototype, or fake door. Ask a few people directly. Measure a real signal like sign‑ups, replies, or pre‑orders. Share what happened. Example: “Thirty replies to a two‑question survey” is stronger than ten likes on a launch tweet.

Validation keeps you from burning months on a product nobody needs.

Distribute Track

Grow awareness and reach more of the right people. List five channels or content ideas, pick one to focus on this week, and ship something public: a post, a short demo, a forum write‑up, a partner outreach. Ask by sharing it in the right rooms. Measure clicks, subscribers, or qualified comments. Share the behind‑the‑scenes. Example: one helpful tutorial that drives ten sign‑ups beats a thread that trends and converts zero.

Distribution builds audience in parallel with product.

Monetize Track

Turn users into paying customers. List five pricing experiments, pick one simple offer, and ship a basic way to buy—a pricing page, a Stripe link, a Gumroad button, or a manual invoice. Ask by pitching directly to prospects. Measure paid conversions or revenue. Share the story of what you tried. Example: two $19 sales from ten DMs tell you more than a hundred “sounds cool” replies.

Monetization replaces vanity growth with revenue evidence.

Retain Track

Keep customers engaged and reduce churn. List five retention ideas—onboarding fixes, bug patches, reminders, small delights. Pick one high‑leverage bet and ship a small improvement. Ask by talking to active, new, or churned users. Measure activation, repeat usage, NPS, or churn. Share how you solved real pain. Example: “Activation rose from 22% to 41% after a two‑step tutorial” is retention evidence.

Retention turns spikes into a stable base.

Choose Your Track

Ask, “Where am I stuck?” No users: run Validate. Users but no attention: run Distribute. Attention but no revenue: run Monetize. Revenue but churn bites: run Retain. Pick one track and run loops until the bottleneck moves. Then switch. Track changes with one sentence per week so you see when it’s time to re‑aim.

Micro‑Exercise

Identify your current bottleneck, choose a track, and run one loop this week aimed squarely at that constraint.

Next, you’ll see how the loop scales from solo to a small team without drowning in process.

Chapter 12: Scaling — From Solo to Small Teams

TenK 6 started as a solo system: one person, six steps, one loop at a time. When a friend joins, a contractor signs on, or you’re suddenly a crew of three to five, many projects collapse under the weight of “team process.” Slack chaos, scattered boards, endless syncs—momentum dies in overhead. The good news: TenK 6 scales without turning into bureaucracy.

Why Teams Stall

Add people and three new problems appear. Visibility drops—nobody knows who’s doing what. Coordination slips—tasks overlap or fall through cracks. Accountability blurs—everyone assumes someone else will move the loop. Big companies solve this with meetings and roadmaps. Indie teams need something lighter.

Scale the Loop, Not the Overhead

Keep the principle: one loop at a time. Make the loop a shared track. List together: brainstorm as a group and capture everyone’s ideas. Pick one with a clear owner. Different people can ship pieces, but the owner stays accountable for the loop. Split the asking—each member gathers feedback from their own network. Track metrics in one visible place. Rotate who shares the story each week. Use async updates to reduce meetings: a daily two‑line check‑in (“what I shipped, what’s blocked”) keeps momentum visible.

Crew Mode in Practice

Use one loop board instead of a hundred task tickets. Track the loop itself with one column per step: List, Pick, Ship, Ask, Measure, Share. Assign a loop owner; they don’t do all the work, but they are accountable end‑to‑end. Keep an evidence folder for screenshots, notes, and metrics—this becomes your collective memory. Close the week with a fifteen‑minute retro: what did we ship, ask, measure, and share? Capture learning before the next loop. If you hit conflict on priorities, defer to the loop’s pick. New ideas can live in the next list—don’t split the current loop across two goals.

Example: Indie10k Crew

When we tested team mode, we didn’t add features—we added constraints. One loop at a time for three people. A shared six‑step board. A rotating storyteller. Instead of three people sprinting in different directions, we had three people compounding one direction.

Micro‑Exercise

If you’re two or more, create a shared six‑step board. Assign an owner for the current loop. Commit as a team: no new loop until the current one finishes. That’s scaling TenK 6—momentum without meetings.

Next comes sustainability—how to keep looping without burning out.

Chapter 13: Sustain — Momentum Without Burnout

Reaching $10k MRR feels huge. The grind doesn’t end there. Many founders burn out right after their first win. They sprint loop after loop, then realize they can’t keep that pace forever. Sustainability isn’t a seventh step; it’s the rhythm that keeps the six steps going.

Why Founders Burn Out

Pace mismatch turns every week into a hackathon. Perfection pressure demands that each loop top the last. Life gets neglected and the project crowds out health, family, and play. Vanity metrics become fuel, and when they dip, motivation collapses. Burnout kills projects, momentum, and joy.

The Pace‑Agnostic Principle

TenK 6 is deliberately pace‑agnostic. You don’t need to finish a loop every week. Some weeks you’ll finish three. Some weeks you’ll crawl through one step. Both count. What matters is not breaking the chain. Keep evidence flowing, no matter how small.

Danger Signs

You dread opening the project. Every loop feels like a chore. You hide results instead of sharing them. You work more hours and make less progress. When you see these, reset your pace before the work resets you.

How to Sustain

Let micro‑loops count. A one‑hour ship is progress. Do an energy check before you start: can you realistically finish this with your current energy? Rotate tracks—switching from Monetize to Distribute can reset motivation. Celebrate small wins: share not just revenue jumps but tiny validated learnings. Take deliberate breaks. A week off beats a permanent stall. Plan seasons: a few fast loops, then a quieter stretch to consolidate.

Example: An Indie10k Plateau

After loop three or four, I hit a slump. Traffic grew; revenue didn’t. I am frustrated. I shortened loops into micro‑experiments, shared raw updates instead of waiting for big ones, and let myself run a “fun loop” alongside growth work. And more importantly, I shift my mindset from “how to grow user” to “today, I will make a tiny growth experiment”. Momentum returned—not because I pushed harder, but because I made space to breathe.

Micro‑Exercise

This week, run a loop with half your usual effort. Make it tiny, easy, even playful. Then reflect: did the world end? That’s sustainability in action.

Next, we’ll close out the tracks with a focus on validation, distribution, monetization, and retention in practice.

Chapter 14: Validate Track — Prove People Care

Most indie projects die not because they’re badly built, but because they solve problems nobody cares about.

That’s why validation is the first track. Before distribution, before monetization, before retention—you need proof that real humans feel the pain you’re solving and want your solution.

The Validate Track is about de‑risking your effort. Instead of investing six months, you invest one loop and leave with evidence you can point to.

Why Validation Matters

Indie founders often skip validation because it feels slow or awkward. They think:

“I’ll just build it and see.”
“If the product is good, users will come.”
“Talking to people isn’t coding. It’s not real work.”

I used to think that too. Which is why I buried 65 projects.

Validation flips that. It forces you to ask: “Do people care enough to respond?” before you pour energy into features. You trade comfort for clarity and learn sooner whether the problem is sharp and present.

Choosing Problems Worth Testing

Write problems, not features. Good candidates sound like pains people already try to solve today. You should be able to name who feels it, when they feel it, and what they do as a workaround. If you can’t, the problem is probably too vague for a first loop.

How to Run a Validate Loop

The six steps of TenK 6 stay the same—but here’s how they look inside validation.

1. List 5 — Capture Hypotheses

Write down five possible problems or customer pains.
Not features. Not solutions. Problems.

Example:

Indie devs abandon projects due to lack of accountability.
Small YouTubers struggle to generate fresh content ideas.
Freelancers lose track of unpaid invoices.
Remote teams get stuck without async visibility.
Parents can’t find kid-friendly, ad-free apps.

2. Pick 1 — Choose One Problem

Select the problem that feels most promising or urgent.
Criteria:

You know people with this problem.
You can test it quickly.
It energizes (or scares) you.

3. Ship 1 — Create a Fast Test

Don’t build a full product. Ship the minimum artifact that lets you test interest. Examples:

A Google Form survey.
A landing page with an email sign-up.
A clickable Figma mockup.
A “fake door” (button that says “Coming Soon”).

The goal isn’t polish—it’s evidence. Ship something a real person can react to in under a minute. If they need ten minutes to understand it, the test is too heavy.

Examples by format:

Landing page: one promise, one screenshot, one button.
Survey: three questions max; one free‑text question to learn words users use.
Mockup: a click‑through of the core flow; no dead‑end walls of text.

4. Ask 3 — Talk to People

Reach out to three potential users:

Friends in the space.
Strangers on forums or Discord.
People tweeting about the problem.

Ask simple questions:

“Do you run into this?”
“How are you solving it today?”
“Would this solution help?”

5. Measure 1 — Track a Real Signal

Pick one metric that shows real interest:

Number of people who gave you their email.
Number of “yes, I’d pay” responses.
Number of survey replies.

If it’s zero, that’s evidence too. Zero responses after honest outreach usually means the problem isn’t sharp, the audience is wrong, or the artifact is unclear. Change one variable and run another tiny test.

Signals vs. Noise

Signals look like action: replies, sign‑ups, calendar bookings, pre‑orders. Noise looks like compliments, likes, and vague “sounds cool.” Treat compliments as encouragement, not validation.

Don’t hide validation results. Share them:

Blog post: “I tested 5 ideas, here’s what happened.”
Tweet thread: “Ran my first validation loop. 17 people said yes to problem X.”
Indie Hackers post: “Survey results show freelancers really struggle with Y.”

Sharing builds credibility and attracts people who care about the problem.

A Real Example: Indie10k Validation

When I first tested the “growth coach” idea (which became Indie10k), I didn’t build a product.

Ship → I made a landing page with a fake login.
Ask → Posted on Indie Hackers, Product Hunt forum, and DM’d a few Reddit users.
Measure → 17 people signed up, 3 messaged me directly saying “this is gold.”
Share → Wrote a build log about why the $10k framing resonated.

That was enough validation to justify the next loop. Importantly, the wording people used in replies (“$10k felt concrete”) became copy on the landing page. Let the market write your headline.

Pitfalls to Avoid

Overbuilding. A landing page beats a full app.
Fishing for compliments. You don’t want “this is cool.” You want action: sign-ups, pre-orders, feedback.
Ignoring silence. No replies = clear evidence. Don’t sugarcoat.
Stalling. Validation doesn’t take months. It takes one loop.
Testing too much at once. Change one thing per loop so you know what moved the number.

Micro-Exercise

Right now:

Write five problems you think are worth solving.
Circle one.
In the next 48 hours, ship a test artifact.
Message three people who match the problem and ask for a two‑minute reaction.

By the end of the week, you’ll have real evidence—not just intuition.

Key Principle: Proof Before Progress

Every Validate loop should leave behind proof: a survey response, a screenshot of sign-ups, a “yes” email, a Stripe pre-order.

If you can’t collect evidence, you haven’t validated.

👉 In Chapter 15: Distribute Track, we’ll move from validation to visibility—growing your audience so more people know about what you’re building.

Chapter 15: Distribute Track — Grow Your Audience

You’ve validated that people care.
Now comes the next bottleneck: getting in front of more people.

You can have the best idea in the world, but if nobody sees it, it’s dead on arrival. Distribution is how you put oxygen on the spark.

This isn’t about going viral. It’s about consistently reaching more of the right people, one loop at a time. Distribution compounds when you show up with useful things, in the right places, on a reliable cadence.

Why Distribution Matters

Indie founders often treat distribution as an afterthought. They think:

“If I build a great product, word will spread.”
“Marketing is cringe, I’ll focus on product.”
“I’ll start posting once I hit $1k MRR.”

That’s backwards. Distribution isn’t optional—it’s the second engine of momentum.

Validation proves there’s demand. Distribution proves you can reach it. Without distribution, insight stays private and progress stalls in the dark.

How to Run a Distribute Loop

The six steps of TenK 6 applied to distribution:

1. List 5 — Channels & Tactics

Brainstorm five possible ways to reach people this week. Examples:

Write a blog post.
Record a short demo video.
Post on Indie Hackers or Reddit.
Run a small paid ad test.
Reach out to a micro-influencer.
Guest post or newsletter swap.
Share a two-minute Loom walkthrough.

2. Pick 1 — Focus on One Channel

Don’t scatter across all five. Choose one.
Criteria:

Where your audience already hangs out.
Something you can execute this week.
A channel you’re willing to test multiple times.

3. Ship 1 — Publish Something

This is the action step. Put something in the world:

Blog post or tutorial.
Tweet thread or LinkedIn post.
YouTube short or TikTok demo.
Partnership email to another founder.

Remember: imperfect but published beats perfect but hidden. Ship something that teaches, not teases.

Don’t just hit “publish” and pray. Actively share with at least three people or communities:

DM a friend and ask for feedback.
Drop the post in a niche Slack/Discord.
Reply to someone else’s thread with your resource.

Distribution isn’t just broadcasting—it’s conversation. Ask for one small action: “Would you share this with one person who needs it?”

5. Measure 1 — Track Reach

Pick one metric that shows distribution is working:

Clicks to your landing page.
Email sign-ups.
Social shares.
Comments from real people.

Don’t obsess over likes. Look for qualified attention. A comment from a fit user beats a hundred impressions from randoms.

Content That Compounds

Favor assets you can reuse: a tutorial that answers a common question, a checklist that speeds a task, a small tool people bookmark. These keep working while you sleep.

Meta is powerful. Share what you tried and what happened:

“I posted my first demo video, got 327 views and 4 sign-ups.”
“Tried a blog post on X community, 12 comments of feedback.”

Even small results inspire others and compound your credibility.

A Real Example: Early Indie10k Distribution

When I had a tiny landing page and a handful of sign-ups, I didn’t buy ads.

Ship → Wrote a short story on Indie Hackers about my 65 failed projects.
Ask → Shared the link in one founder Discord and to a friend over DM.
Measure → 400 views, 20 sign-ups, 5 comments of encouragement.
Share → Posted a build log: “Turns out, my story resonated more than the tool.”

That loop did more for traction than months of silent coding ever did. It also gave me a piece I could send in DMs for weeks—one asset, multiple uses.

Pitfalls to Avoid

Trying everything at once. Scattering weakens signal. Focus on one channel per loop.
Chasing vanity. A thousand impressions mean nothing if nobody clicks through.
Inconsistency. One post won’t grow you. Ten loops will.
Copying blindly. What worked for a SaaS giant won’t necessarily work for you.
Posting without a follow‑up. Plan what you’ll do when someone replies or asks a question.

Micro-Exercise

Right now, list five ways you could put your work in front of people this week.
Circle one.
Ship it in the next 48 hours.

At the end of the week, measure one thing: did it reach anyone new—and did any of them take a next step?

Key Principle: Consistent Visibility

Distribution isn’t about a single viral hit.
It’s about showing up, week after week, until people know you exist and trust what you’re building.

Every Distribute loop adds surface area for serendipity. The more you show up, the more luck finds you. Show your work. Teach one thing. Invite one action.

👉 In Chapter 16: Monetize Track, we’ll move from reach to revenue—converting attention into paying customers through simple pricing experiments.

Chapter 16: Monetize Track — Turn Attention Into Revenue

Validation proves people care.
Distribution gets more people to notice.
But here’s the truth: attention alone isn’t a business.

At some point, you have to ask for money. Do it earlier than feels comfortable so you learn whether you have a business or a fan club.

That’s what the Monetize Track is for—turning curiosity into cash. Not with a perfect business model, but with small, evidence-based pricing experiments.

Why Monetization Matters Early

Indie founders delay monetization out of fear. They tell themselves:

“I’ll charge once I have more features.”
“Nobody will pay this early.”
“I’ll add pricing once I hit 1,000 users.”

That’s the graveyard mindset.
Because if people won’t pay, you don’t have a business—you have a hobby.

Charging early doesn’t kill momentum. It creates it. Every dollar validates your idea more than a hundred compliments ever will. A single payment flips your mindset from “maybe” to “we have customers.”

How to Run a Monetize Loop

1. List 5 — Pricing Experiments

Brainstorm five different ways you could test revenue:

Monthly subscription tiers.
One-time purchase / lifetime deal.
“Pay what you want.”
Free trial → paid upgrade.
Consulting / service add-on.

2. Pick 1 — Focus on One Offer

Choose a model that feels realistic to test this week.
Criteria:

Simple to explain.
Quick to implement.
Low risk for both you and the customer.

3. Ship 1 — Make It Purchasable

Ship a basic monetization test:

Add a Stripe checkout button.
Create a Gumroad page.
Publish a pricing page (even with one option).
Manually invoice someone via PayPal.

The goal isn’t perfect billing infra—it’s proof people will pay. Add the button. You can clean up invoicing later.

Quick Pricing Tips

Anchor with a clear outcome: “Save 3 hours a week for $19/month.”
Fewer choices convert better; start with one plan.
Round pricing unless a specific number has meaning.

4. Ask 3 — Pitch Directly

Find three real prospects and present your offer:

DM people who showed interest.
Email sign-ups who engaged.
Reach out in communities where you already share progress.

Ask them directly: “Would you pay $X for this?” Follow with, “What would make it a clear yes?”

5. Measure 1 — Track Real Revenue Signals

Choose one clear metric:

of people who paid.
$ of revenue collected.
Conversion % from free to paid.

Remember: intent is nice, but only money counts. Track trials‑to‑paid if you run free trials; otherwise count purchases.

Sharing your monetization experiments builds credibility. Examples:

“Tested $9/month vs $19/month—5 people picked $19.”
“Launched my first pricing page. Zero sales, but lots of feedback.”
“Made $87 this week from a Gumroad button. First dollar online!”

People respect founders who charge and share transparently. Share refunds too—they build trust.

A Real Example: Early Monetization

When I added pricing to Indie10k, I didn’t over-engineer.

Ship → A simple public pricing page. No complicated Stripe integration at first.
Ask → Reached out to early users, offered lifetime discount if they ran one real loop.
Measure → 3 people paid within the first week.
Share → Posted: “Our first $57 MRR! Here’s how we tested it.”

That tiny win created more momentum than any number of free sign-ups. It also gave me permission to ask better questions: “What did you expect at $19?”

Pitfalls to Avoid

Analysis paralysis. Don’t spend weeks debating $9 vs $12. Pick one and test.
Hiding pricing. If your pricing page says “contact us,” you’re stalling.
Over-engineering. Stripe, Gumroad, or PayPal—all fine. Don’t wait for perfect billing flows.
Confusing free with validation. Free users ≠ paying customers.
Hiding behind discounts. Temporary promos are fine; permanent sales hide pricing problems.

Micro-Exercise

This week, create one pricing test:

Add a “Buy” button.
Post a lifetime deal.
Offer a service add-on.

Then pitch it to three people. If all three say no, ask each what would have made it a yes.

By the end of the week, you’ll know: did anyone care enough to pay?

Key Principle: Dollars Are the Strongest Signal

Compliments, clicks, and sign-ups are nice. But a payment—no matter how small—is the clearest evidence you’re solving a real problem. Optimize for earning a first dollar fast, then improve from there.

👉 In Chapter 17: Retain Track, we’ll focus on keeping those customers once you’ve won them—turning one-time wins into compounding revenue.

Chapter 17: Retain Track — Keep Customers Engaged

Getting customers is hard.
Losing them is easy.

That’s why retention matters.
If validation proves demand, distribution grows awareness, and monetization turns attention into dollars—retention is how you build a durable business.

Because $10k MRR isn’t just about sales. It’s about keeping those dollars month after month. Retention makes growth sticky.

Why Retention Is Everything

Indie founders often obsess over acquisition while ignoring retention. They chase new sign-ups while current users quietly churn.

The math is brutal:

If you add 10 customers a week but lose 8, you’re barely moving.
If you keep most of what you win, even slow growth compounds into a stable base.

Retention turns spikes into plateaus and plateaus into upward curves.

How to Run a Retain Loop

TenK 6 doesn’t change—you just apply it to keeping customers.

1. List 5 — Retention Ideas

Brainstorm five ways to help users stick around:

Simplify onboarding.
Fix a frustrating bug.
Add a reminder email.
Build a small “delight” feature.
Write a quick-start guide.
Add a “what’s new” note in‑app.
Offer a 15‑minute onboarding call for new customers.

2. Pick 1 — Choose the Highest Leverage Fix

Select the one that feels most impactful this week. Criteria:

Solves a common frustration.
Helps users get to value faster.
Easy enough to ship quickly.

3. Ship 1 — Implement the Change

Don’t overbuild. Ship a small improvement:

Add a tooltip or demo video.
Send a weekly “success recap” email.
Add a nudge when users stall on step one.
Fix the bug that users complain about most.

4. Ask 3 — Talk to Real Users

Reach out to three customers:

Active users → ask what keeps them around.
Churned users → ask why they left.
New users → ask if onboarding was clear.

The best retention ideas come straight from these conversations. Script starters: “What almost made you quit?” for churned users; “What helped you succeed fastest?” for active users.

5. Measure 1 — Track Engagement

Pick one retention metric:

% of users who log in weekly.
% of trials that convert to paid.
Churn rate (cancellations).
NPS or customer satisfaction.
Time‑to‑value for new users.

Even small changes in retention create long-term impact.

Retention stories resonate because they’re rare.
Examples:

“Fixed onboarding, activation rate doubled.”
“Sent a weekly success email—4 customers re-engaged.”
“Interviewed churned users—realized pricing wasn’t the problem, setup was.”

Sharing proves you’re not just chasing hype—you’re building for durability. Retention stories help others and attract users who value staying power.

A Real Example: Indie10k Retention

When early Indie10k users signed up, some never touched the product again. At first, I thought I needed more features.

But after a few user chats, the real issue was onboarding: people didn’t understand how to start a TenK 6 loop.

Ship → Added a guided “first loop” tutorial.
Ask → Interviewed 3 users about the new flow.
Measure → Activation rate rose from ~20% to ~60%.
Share → Posted the update on Indie Hackers: “Turns out onboarding, not features, was killing momentum.”

That loop mattered more than any new feature could. It taught me to start every quarter by checking activation first.

Pitfalls to Avoid

Endless features. Adding shiny new things ≠ retention. Fixing pain points does.
Ignoring churn. If people cancel, talk to them. Silence is feedback too.
Measuring vanity. Daily active users sound nice, but revenue churn tells the real story.
Over-automation. Manual check-ins with customers can be more powerful than fancy retention systems.
Ignoring activation. If new users don’t reach value quickly, no later retention tactic will stick.

Micro-Exercise

Think of one reason a user might leave your product. Ship a fix this week—email, feature tweak, or onboarding step. Ask three users what they think. Measure if engagement improves. Write one sentence about what you’ll try next.

Key Principle: Retention Compounds

Every customer you keep adds to the base for next month’s growth.
Retention isn’t glamorous, but it’s the difference between sprinting forever and building a business that lasts.

👉 With Retain covered, you now have all four tracks: Validate, Distribute, Monetize, Retain.
Together with the six core loops, they form a complete system for compounding indie momentum.

Chapter 18: Outro — Your First Loop Starts Now

You’ve reached the end of this handbook.
But really, this isn’t the end. It’s the beginning.

You now know the rhythm:
List → Pick → Ship → Ask → Measure → Share.
Six steps. One loop. Evidence over intuition.

The magic of TenK 6 isn’t in reading about it.
It’s in running it.

The Indie Founder Advantage

You don’t need a big team, a giant budget, or investor permission.
As an indie founder, you have speed, focus, and freedom.

What you need is momentum.
And momentum is built loop by loop.

What Happens Next

Here’s the only task I’ll leave you with:

👉 Run your first loop.

Write down 5 ideas tonight.
Pick one tomorrow.
Ship something this week.
Ask 3 people for feedback.
Measure one thing that matters.
Share your progress publicly.

That’s it. One loop.

When you finish, reflect. Then run another.
And another.
And another.

Soon, you’ll look back and realize: you didn’t just ship features—you built momentum.

A Final Word

Reaching $10k MRR isn’t magic.
It’s not luck.
It’s the compounding effect of dozens of small loops, stacked patiently and relentlessly.

The sooner you start, the sooner momentum takes over.

So don’t just close this book.
Close your laptop, grab a sticky note, and write:

List 5.

Your first loop starts now.

Keyboard shortcuts

The TenK 6 Handbook