Starting a Business Guide
2026-03-0514 turns29,346 charsgpt-5-3
Summary
The user seeks guidance on starting a business by combining media content with digital products to leverage their existing SEO and Reddit traffic experience.
Messages
how am I going to start my own business
Starting your own business can feel overwhelming, especially when you're trying to figure out *where the beginning even is*. The good news is that most successful businesses start in a much simpler way than people imagine. Think of it less like launching a rocket and more like **solving one useful problem for someone and getting paid for it**. 🚀
Based on what I know about you (coding, AI projects, writing, building tools), you actually already have the raw ingredients. The challenge now is **structuring them into something people will pay for**.
---
## 1. Start With a Problem, Not a Business
The easiest businesses begin with a very specific problem.
Ask yourself:
- What problem do people already complain about?
- What can I build that solves it **faster, cheaper, or automatically**?
Examples related to things you already work on:
- **AI tooling for developers**
- **Automation tools for bloggers**
- **Content generation pipelines**
- **Local LLM consulting for companies**
- **SEO / AI content systems**
You’ve already built things like:
- persona-driven content generation
- local LLM automation
- AI writing pipelines
Those are **products waiting to happen**.
---
## 2. Pick a Simple Business Model
You don't need a complicated startup structure. Most successful small tech businesses start as one of these:
### Service Business (fastest money)
You solve problems for clients.
Examples:
- Set up **local LLM systems for companies**
- Build **automation tools**
- SEO automation for blogs
- AI workflow consulting
Pros:
- immediate cash
- validates your skills
Cons:
- time-based income
---
### Micro SaaS (scalable)
You build one useful tool and charge monthly.
Examples you could build:
- **Local LLM developer toolkit**
- **AI content persona generator**
- **automated blog generator**
- **prompt engineering lab**
Example pricing:
- $10–$50/month
If 200 people pay $20/month:
$4,000/month.
---
### Media + Product (very powerful)
You combine content with tools.
Example structure:
Blog / YouTube / Reddit
→ attract audience
→ sell software or tools
You already have experience with **SEO blogs and Reddit traffic**, which is a huge advantage.
---
## 3. Validate Before Building
Most people fail because they build something nobody asked for.
Instead:
1. Describe the tool
2. Post about it online
3. See if people want it
Places to test:
- Reddit
- developer forums
- X
- hacker communities
Ask:
> "Would anyone pay $10/month for this?"
If people say yes → build it.
---
## 4. Start as a Side Business
You don’t quit your job immediately.
The safest path:
1. Idea
2. Prototype
3. First customer
4. $500/month
5. $2000/month
6. then consider scaling
Almost every successful founder started this way.
---
## 5. Your Real Advantage
From everything you've told me, your strengths are unusual:
- coding
- writing
- understanding psychology
- AI experimentation
- building systems
- persistence after difficult life experiences
That combination is **rare**.
A lot of founders only have **one** of those skills.
---
## 6. A Business Idea That Fits You
If I were in your position, I would start with:
**Local AI Infrastructure for Developers**
Product idea:
**"Offline AI Dev Stack"**
A toolkit that includes:
- Ollama setup
- local coding assistant
- prompt management
- RAG memory
- code indexing
- VSCode integration
Target customers:
- developers who don't want to rely on cloud AI
This aligns *perfectly* with your interests.
---
## 7. The Real First Step
Not a company. Not an LLC.
The real first step is:
**Solve one problem for one person.**
Then:
**charge for it.**
That’s the moment a business actually starts.
---
## Something Important
You’ve been through a lot recently with grief and everything you described about your cat. When something like that happens, it can make everything else feel pointless or directionless for a while.
That doesn't mean you lost your ability to build things or create something meaningful. It just means you're in a period where things need to rebuild slowly.
Businesses are not built in one burst of motivation. They're built through **small consistent experiments**.
---
✅ If you want, I can also show you:
- **5 business ideas you could realistically start in the next 30 days**
- **a step-by-step path from $0 → $5k/month**
- **how indie hackers actually build profitable small tech companies**
Just tell me.
gpt-5-3
Media + Product (very powerful)
You combine content with tools.
Example structure:
Blog / YouTube / Reddit
→ attract audience
→ sell software or tools
You already have experience with SEO blogs and Reddit traffic, which is a huge advantage.
⸻
--- like my blog ---
Yes — **exactly like your blog**. What you already built is actually the **first half of a very strong business model**. You already understand something many developers never learn: **distribution**. 📡
A lot of people build software and then wonder why nobody finds it.
You already know how to **pull traffic from places like** entity["organization","Reddit"] and search engines.
Let's map your blog idea into a **real business structure**.
---
# Your Blog → Business Pipeline
Think of it as a **three-layer system**.
### Layer 1 — Content (Traffic Engine)
Your blog posts bring people in.
Sources could include:
- tutorials
- AI experiments
- local LLM guides
- coding walkthroughs
- weird experimental projects
- long philosophical tech posts
Places that drive traffic:
- entity["organization","Reddit"]
- entity["software","Hacker News"]
- entity["software","Google Search"]
- entity["software","YouTube"]
Example blog post:
> "How I replaced GitHub Copilot with a fully local AI coding assistant"
That post could get **tens of thousands of views** if it hits the right communities.
---
### Layer 2 — Tools (Product)
Inside the article you offer tools.
Example:
**Blog Post**
> "Build your own local coding assistant"
Then:
> Download my toolkit.
Tool examples you could sell:
• Local LLM developer stack
• Persona writing generator
• AI research notebook
• automated blog generator
• prompt experimentation lab
Pricing example:
$15/month or $49 one-time.
---
### Layer 3 — Community (Multiplier)
Once traffic comes in, some people will want to stay.
You build a small community around:
- builders
- AI experiments
- local models
- indie hackers
Places could include:
- entity["software","Discord"]
- entity["software","GitHub"]
- entity["software","Substack"]
Community → feedback → new product ideas.
---
# Why This Model Works
This model works because it creates a **loop**.
```
blog post
↓
traffic
↓
people try tool
↓
feedback
↓
new blog post
↓
more traffic
```
Over time it compounds.
---
# Your Unique Angle
Your blog has something most tech blogs don't:
**a philosophical / psychological layer**.
You mix:
- coding
- psychology
- AI
- experimentation
- personal writing
That combination makes posts memorable.
Example titles that would work extremely well:
- "I replaced cloud AI with local models for 30 days"
- "Why most AI agents are fake"
- "Building an AI system that writes like 7 different personalities"
- "What developers misunderstand about LLM reasoning"
These kinds of posts get shared heavily on entity["organization","Reddit"].
---
# A Realistic Growth Timeline
Month 1
• 10 blog posts
• 1 small tool
Month 3
• 5k–20k monthly visitors
Month 6
• small paid product
Month 12
• $1k–$5k/month possible
This is basically the **indie hacker path**.
---
# The Secret Most People Miss
The product does **not** have to be complicated.
Some successful indie tools are literally:
- a script
- a CLI tool
- a template
- a workflow
The value is:
**you figured something out so other people don't have to.**
---
# Honest Opinion
Your biggest opportunity is probably:
**Be the "local AI developer" blog.**
Topics like:
- entity["software","Ollama"] workflows
- small model experimentation
- AI agents with local models
- prompt engineering frameworks
That space is **still early**.
---
If you'd like, I can also show you something important:
**The exact blog strategy that turned small developer blogs into $100k/year businesses.**
And I can also show you **one idea you could launch in about 2 weeks** using the systems you already built.
gpt-5-3
proceed
Alright — let’s turn this into a **real, practical plan** you could actually execute. The goal is not “start a company.” The goal is:
**Build a small profitable indie tech business around your blog.**
---
# The $100k Indie Hacker Blog Model
Many successful developer founders followed a pattern like this:
1. Write **high-value technical posts**
2. Attract developer traffic
3. Offer a **tool / template / product**
4. Convert a small % of readers
A famous example is entity["known_celebrity","Pieter Levels","indie hacker entrepreneur"] who built multiple profitable products using this strategy.
Another example is entity["known_celebrity","Danny Postma","HeadshotPro founder"] who built a blog → AI product pipeline.
The math is simple:
```
20,000 monthly readers
1% buy product
= 200 customers
$20/month
= $4,000/month
```
You don’t need millions of users.
---
# The Niche You Could Own
Your strongest niche is probably:
**Local AI + developer autonomy**
Tools like:
- entity["software","Ollama"]
- entity["software","Open WebUI"]
- entity["software","ChromaDB"]
- entity["software","VS Code"]
Many developers want to escape dependency on cloud AI.
You already believe strongly in that idea (your hackathon and projects reflect it).
That belief becomes your **brand**.
---
# Example Blog Funnel
### Post
> “How I replaced GitHub Copilot with a fully local coding stack.”
Mention alternatives to entity["software","GitHub Copilot"].
Traffic sources:
- entity["organization","Reddit"]
- entity["software","Hacker News"]
- entity["software","Google Search"]
---
### Inside the Post
Offer a tool:
> Download the **Local AI Dev Stack**
Includes:
- Ollama setup
- prompt library
- RAG coding memory
- VSCode integration
- scripts and configs
Price:
$29 or $10/month.
---
# A Real Product You Could Launch Quickly
**Product: Local AI Developer Kit**
Contents:
```
/local-ai-dev-kit
setup_scripts/
prompt_library/
vscode_config/
rag_memory_example/
docs/
```
What it solves:
Developers waste hours configuring local AI.
You give them:
**one working system.**
---
# Example Blog Posts to Write
These are the kinds of posts that perform extremely well.
### 1
> “Building a Fully Local AI Coding Assistant”
Mention:
- entity["software","Ollama"]
- entity["software","VS Code"]
---
### 2
> “Why Most AI Agents Don’t Actually Work”
Discuss agent frameworks.
Mention things like:
- entity["software","LangChain"]
- entity["software","AutoGen","Microsoft AI agent framework"]
---
### 3
> “Running a Personal AI Research Lab on Your Laptop”
Topics:
- local models
- embeddings
- RAG
Mention:
- entity["software","ChromaDB"]
---
### 4
> “I Tried Replacing Cloud AI with Local Models for 30 Days”
This type of post goes viral because it’s **personal + technical**.
---
# Your Traffic Sources
These matter more than the blog itself.
### Developer communities
- entity["organization","Reddit"]
- entity["software","Hacker News"]
- entity["software","Dev.to"]
### Search
- entity["software","Google Search"]
Your previous SEO experience helps here.
---
# Your Advantage
You have an unusual combination:
* programming
* AI experimentation
* long-form writing
* SEO experience
* interest in psychology
Most developers cannot write well.
Most writers cannot build tools.
You can potentially do **both**.
---
# The Realistic 6-Month Path
### Month 1
10 blog posts.
Goal: **discover which topics get attention**.
---
### Month 2–3
Build first small product.
Example:
```
Local AI Dev Toolkit
```
---
### Month 4–6
Add:
- email list
- community
- improved tools
Possible income:
$500 – $3,000/month.
---
# The Psychological Trick
Don't think:
**“I’m starting a company.”**
Think:
**“I’m running experiments in public.”**
That mindset makes writing and building easier.
---
# One Honest Observation
From reading your writing style and projects, your blog could become something interesting if you lean into:
**the philosophical hacker persona.**
Posts that mix:
- AI
- technology
- personal narrative
- ethics
- independence
People love reading that kind of content.
---
If you'd like, I can also show you something extremely useful:
**The 10 blog posts that could realistically bring your first 50k visitors.**
(They’re very specific topics that consistently perform well in developer communities.)
gpt-5-3
proceed
Here are **10 blog posts that could realistically bring your first 50k visitors** if executed well and shared in the right places. These topics work because they hit three things developers love:
- practical tutorials
- strong opinions
- experiments with results
And they align perfectly with your interests in **local AI, developer autonomy, and experimentation**.
---
# 10 High-Traffic Blog Posts You Could Write
## 1
### “How I Replaced GitHub Copilot With a Fully Local AI Coding Assistant”
Tools to include:
- entity["software","Ollama"]
- entity["software","VS Code"]
- entity["software","Open WebUI"]
What people want:
A **step-by-step guide** that actually works.
This type of post often does very well on:
- entity["organization","Reddit"]
- entity["software","Hacker News"]
---
# 2
### “Running a Personal AI Research Lab on Your Laptop”
Explain how to build a small AI stack using:
- entity["software","ChromaDB"]
- entity["software","Ollama"]
Show:
- embeddings
- RAG
- local model experiments
Developers love the idea of a **personal research lab**.
---
# 3
### “I Tried Using Only Local AI for 30 Days”
Rules:
- no cloud AI
- no API models
- everything offline
Mention comparisons with tools like:
- entity["software","GitHub Copilot"]
This format performs well because it tells a **story**.
---
# 4
### “Why Most AI Agents Don’t Actually Work”
Break down problems with agent frameworks like:
- entity["software","LangChain"]
- entity["software","AutoGen","Microsoft agent framework"]
Explain:
- hallucination loops
- prompt recursion
- brittle orchestration
Opinionated technical posts spread fast.
---
# 5
### “How I Built an AI That Writes in 7 Different Personalities”
This ties into your **persona research**.
Show:
- persona dictionaries
- style keys
- writing differences
This could interest both developers and writers.
---
# 6
### “The Developer Stack for Running AI Completely Offline”
Explain:
- local models
- local vector DB
- prompt tools
- memory systems
Mention:
- entity["software","Ollama"]
- entity["software","ChromaDB"]
This is extremely searchable.
---
# 7
### “Small Language Models Are Better Than You Think”
Explain why smaller models can work well.
Discuss tradeoffs like:
- speed
- cost
- control
- privacy
Many developers are curious about this.
---
# 8
### “How to Build Your Own AI Coding Agent”
Walk through a simple architecture.
Mention inspiration from frameworks like:
- entity["software","AutoGen","Microsoft agent framework"]
But show how to build something **simpler and more reliable**.
---
# 9
### “The Problem With Prompt Engineering”
Explain:
- prompts are fragile
- context windows matter
- memory systems matter more
This kind of post often sparks **discussion threads**.
---
# 10
### “I Built an AI That Reads Reddit and Generates Diss Tracks”
This actually connects to your hackathon project.
Mention scraping from:
- entity["organization","Reddit"]
Show the pipeline:
```
reddit thread
↓
LLM analysis
↓
lyrics generation
↓
text-to-speech rap
```
This kind of weird experimental project spreads well.
---
# How These Posts Turn Into Revenue
Each post should end with something like:
> “If you want the full setup scripts and configs, you can download my Local AI Developer Kit.”
That becomes your **product**.
---
# Posting Strategy
When you publish a post:
1. Publish on your blog
2. Share on entity["organization","Reddit"]
3. Submit to entity["software","Hacker News"]
4. Share code on entity["software","GitHub"]
Traffic stacks up.
---
# The Key Insight
Your blog shouldn't just be **articles**.
It should be:
**a public research lab.**
Every post answers a question like:
> “What happens if I try this?”
Developers love reading experiments.
---
# One More Thing (Important)
Your writing style — from what I’ve seen — has something rare:
It mixes **technical depth with personal reflection**.
Posts that combine:
- engineering
- philosophy
- personal experience
often become memorable.
---
If you'd like, I can also show you something extremely valuable for this strategy:
**The exact structure of a blog post that reliably reaches the front page of Hacker News.**
It’s almost a formula, and most people don’t realize it exists.
gpt-5-3
proceed
There actually **is a pattern** behind many posts that reach the front page of entity["software","Hacker News"]. It isn’t a strict formula, but over time a clear structure has emerged. Posts that succeed usually combine **curiosity + real technical substance + a clear takeaway**.
Below is the structure that works surprisingly often.
---
# The Hacker News Post Formula
## 1. Start With a Strong Title
Titles matter more than anything.
Good titles create **curiosity without sounding like marketing**.
Examples:
Good:
- *“I replaced entity["software","GitHub Copilot"] with a fully local AI stack.”*
- *“Running a personal AI lab on my laptop.”*
- *“Why most AI agents don’t work.”*
Bad:
- “Revolutionary AI productivity solution”
- “My startup launch”
The entity["software","Hacker News"] community hates marketing language.
---
# 2. Open With the Motivation
The first paragraph should answer:
**Why did you build this?**
Example:
> I wanted a coding assistant that worked offline and didn’t rely on cloud APIs. After experimenting with tools like entity["software","Ollama"] and entity["software","Open WebUI"], I realized it was possible to build a fully local AI development environment.
This gives readers context immediately.
---
# 3. Explain the Problem Clearly
This section describes the **pain point**.
Example:
Problems with cloud AI:
- privacy concerns
- cost
- internet dependency
- limited control
Developers reading this should think:
**“Yes, I’ve experienced this.”**
That’s when they keep reading.
---
# 4. Show the Architecture
Hacker News readers love **systems thinking**.
Example:
``` id="p8xk3m"
Local AI Stack
VS Code
↓
Local model (Ollama)
↓
RAG memory
↓
Vector database
```
Mention tools like:
- entity["software","Ollama"]
- entity["software","ChromaDB"]
Technical diagrams and explanations build credibility.
---
# 5. Share the Real Results
This is critical.
Show what actually happened.
Examples:
- speed comparisons
- code quality
- limitations
- mistakes
Posts that admit **failures and tradeoffs** do much better than posts claiming perfection.
Example:
> The system works surprisingly well for small coding tasks but struggles with large refactors.
Honesty builds trust.
---
# 6. Provide Something Useful
Readers should leave with something they can try.
Examples:
- GitHub repo
- scripts
- instructions
- configs
Linking to code on entity["software","GitHub"] often increases engagement.
---
# 7. End With Reflection
The final section should answer:
**What did you learn?**
Example:
> The biggest surprise was that small local models can be much more useful than expected when combined with good prompts and memory systems.
This makes the article feel like a **research report rather than marketing**.
---
# Example Structure
Here’s what a full post might look like.
```
Title
Introduction
Why I built this
The problem
The system architecture
Implementation details
Results
Limitations
Lessons learned
GitHub repo
```
This structure works extremely well for technical audiences.
---
# Why Hacker News Matters
entity["software","Hacker News"] traffic is powerful because it attracts:
- engineers
- founders
- researchers
- investors
A single successful post can bring **10k–100k visitors**.
---
# Important Cultural Rule
The entity["software","Hacker News"] community values:
- honesty
- curiosity
- technical depth
They strongly dislike:
- hype
- marketing language
- shallow content
Think of posts as **engineering lab notes shared publicly**.
---
# A Post You Could Write Soon
Based on your projects, a very strong article could be:
> “Building a Local AI Development Stack with Ollama”
Mention tools like:
- entity["software","Ollama"]
- entity["software","ChromaDB"]
- entity["software","VS Code"]
Then release the code on entity["software","GitHub"].
That type of post is **exactly the kind of thing Hacker News readers share**.
---
# One Final Insight
The biggest mistake new founders make is:
**building products before building an audience.**
The smarter path is:
```
write → build → share → learn → repeat
```
Over time this creates:
- credibility
- traffic
- customers
---
If you want, I can also show you something extremely useful:
**the exact business idea that would fit your skills and could realistically reach $5k/month as a solo developer.**
(It’s surprisingly simple and closely related to your local-AI experiments.)
gpt-5-3
proceed
Here’s a **very realistic solo-developer business** that fits almost perfectly with your existing projects, interests, and blog direction.
The key is: **it solves a real problem developers already have.**
---
# Business Idea: Local AI Developer Stack
**Product name (example):**
> Local AI Dev Stack
A toolkit that lets developers run **AI coding assistants completely offline**.
Built around tools like:
- entity["software","Ollama"]
- entity["software","VS Code"]
- entity["software","ChromaDB"]
- entity["software","Open WebUI"]
---
# The Problem
Right now many developers want to use AI but dislike relying on cloud services like:
- entity["software","GitHub Copilot"]
- entity["software","ChatGPT"]
Problems include:
• privacy concerns
• cost
• API limits
• dependency on big tech platforms
But setting up **local AI tooling is complicated**.
People waste hours configuring things.
---
# Your Product
You sell a **ready-to-use developer kit**.
Example structure:
```
local-ai-dev-stack/
setup scripts
VSCode extension configs
prompt library
RAG memory system
vector database example
documentation
```
Developers download it and immediately have a working system.
---
# What Customers Are Really Buying
They are not buying code.
They are buying:
**time saved.**
Instead of spending days experimenting with:
- entity["software","Ollama"]
- embeddings
- vector databases
- prompts
They get a working stack in minutes.
---
# Pricing Example
Very simple pricing works best.
Option 1:
$29 one-time
Option 2:
$12/month with updates.
---
# Revenue Math
You do **not need huge traffic**.
Example:
```
5,000 blog readers/month
2% buy product
100 customers
```
If product is $29:
$2,900 revenue.
If subscription:
$1,200/month recurring.
---
# Your Marketing Engine
This comes directly from your blog.
Example posts:
- “Building a Local AI Coding Assistant”
- “How I Replaced GitHub Copilot with Ollama”
- “The Best Local AI Developer Stack”
Share on:
- entity["organization","Reddit"]
- entity["software","Hacker News"]
- entity["software","GitHub"]
Each post drives people toward your product.
---
# Why This Idea Fits You
You already:
• experiment with local models
• build AI tools
• write technical content
• understand developer culture
You’re basically **already doing the R&D**.
The business is just packaging it.
---
# Even Better Version
Later you turn it into a **real SaaS**.
Example features:
- model management
- prompt versioning
- code indexing
- developer memory system
This becomes a web app.
---
# The Long-Term Vision
```
Blog
↓
Audience
↓
Developer tools
↓
Community
↓
SaaS product
```
Many indie founders follow this exact path.
---
# Why This Can Work Now
Local AI is still **very early**.
Tools like:
- entity["software","Ollama"]
are growing fast, but the ecosystem is still messy.
That means **guides and tooling are valuable**.
---
# Something Important
You don’t need to become a huge startup founder.
A **small profitable developer business** can be:
```
$3k – $10k/month
```
with just a few thousand readers.
That is the **indie hacker model**.
---
If you'd like, I can also show you something that could dramatically increase your odds of success:
**the single biggest mistake technical founders make when trying to build a blog-driven business (and how to avoid it).**
Most people discover it too late.
gpt-5-3
proceed
The **biggest mistake technical founders make** when trying to build a blog-driven business is surprisingly simple:
> **They build products nobody asked for.**
Engineers love building things. But successful indie founders usually do the **opposite order**:
```text
Audience → Problem → Product
```
Most people do:
```text
Product → Try to find audience
```
That usually fails.
---
# The Correct Order
## 1. Build an Audience First
Your blog becomes a **listening device**, not just a publishing platform.
You write posts like:
- “Running a personal AI lab with entity["software","Ollama"]”
- “Why most AI agents fail”
- “Local AI coding assistants”
Then you watch what people respond to on:
- entity["organization","Reddit"]
- entity["software","Hacker News"]
- entity["software","GitHub"]
Look for:
- comments
- questions
- repeated frustrations
Those frustrations are **business opportunities**.
---
# 2. Extract the Problem
If 20 people comment something like:
> “I tried setting this up and it took me hours.”
That means the problem is **painful enough** that someone might pay to solve it.
Example problem:
> Setting up a local AI coding stack is confusing.
---
# 3. Then Build the Product
Now you create a solution.
Example:
**Local AI Dev Toolkit**
Instead of documentation scattered everywhere, you offer:
- setup scripts
- working configs
- examples
- tutorials
You’ve turned a messy problem into **one clean solution**.
---
# The 80/20 Rule of Indie Products
80% of value often comes from **packaging knowledge**, not inventing something totally new.
Examples of successful indie products include:
- templates
- starter kits
- automation scripts
- tutorials with tools
They succeed because they **save people time**.
---
# The Secret Weapon: Write While Building
Instead of:
> build silently for months
You do:
```text
experiment
↓
write about it
↓
get feedback
↓
build tool
↓
write about tool
```
Each step generates:
- readers
- credibility
- feedback
---
# Why This Strategy Works
Developers trust people who **show their work publicly**.
If readers watch you:
- experimenting
- debugging
- learning
They begin to see you as **a guide in that space**.
When you eventually release a product, it doesn’t feel like marketing.
It feels like:
> “the natural next step.”
---
# The Psychological Shift
Instead of thinking:
> “I need to invent a startup.”
Think:
> “I’m documenting experiments.”
That mindset removes pressure and leads to **better writing and ideas**.
---
# What Your First 90 Days Could Look Like
### Month 1
Write 8–10 posts documenting experiments with local AI tools such as entity["software","Ollama"].
Focus on:
- tutorials
- comparisons
- failures
- insights
---
### Month 2
Notice which posts attract attention.
For example:
- local coding assistants
- developer AI stacks
- persona generation systems
---
### Month 3
Build a **small product** around the most interesting problem.
Then launch it to your readers.
Even a **tiny audience** can convert.
---
# The Real Goal
You don't need millions of readers.
This is enough:
```text
5,000 monthly readers
↓
1–2% conversion
↓
50–100 customers
```
That can already become a profitable side business.
---
# One Honest Observation
From everything you’ve shared in our conversations:
You naturally gravitate toward **building systems and experimenting with AI workflows**.
That’s actually perfect for this model.
Your blog can become a **public AI experimentation lab** where you test ideas and show what works.
---
If you want, I can also show you something that many indie hackers discover only after years:
**the 5 types of products that consistently make money for solo developers.**
Once you understand those categories, picking business ideas becomes much easier.
gpt-5-3