Module T: Technical Moats

STREETS Developer Income Playbook Weeks 3-4 | 6 Lessons | Deliverable: Your Moat Map

"Skills that can't be commoditized. Niches that can't be competed away."

Module S covers the infrastructure — your rig, a local LLM stack, legal basics, a budget, and a Sovereign Stack Document. That's the foundation. But a foundation without walls is just a slab of concrete. (Complete Module S first for maximum value from this module.)

This module is about walls. Specifically, the kind of walls that keep competitors out and let you charge premium prices without constantly looking over your shoulder.

In business, these walls are called "moats." Warren Buffett popularized the term for companies — a durable competitive advantage that protects a business from competition. The same concept applies to individual developers, but nobody talks about it that way.

They should.

The difference between a developer earning $500/month from side projects and one earning $5,000/month is almost never raw technical skill. It's positioning. It's the moat. The $5,000/month developer has built something — a reputation, a dataset, a toolchain, a speed advantage, an integration nobody else has bothered to build — that makes their offering hard to replicate even if a competitor has the same hardware and the same models.

By the end of these two weeks, you will have:

• A clear map of your T-shaped skill profile and where it creates unique value
• Understanding of the five moat categories and which ones apply to you
• A practical framework for selecting and validating niches
• Knowledge of the 2026-specific moats that are available right now
• A competitive intelligence workflow that doesn't require expensive tools
• A completed Moat Map — your personal positioning document

No vague strategy talk. No "find your passion" platitudes. Concrete frameworks, real numbers, real examples.

Let's build your walls.

Lesson 1: The T-Shaped Income Developer

"Deep in one area, competent in many. This is how you escape commodity pricing."

Why Generalists Starve

If you can do "a bit of everything" — some React, some Python, some DevOps, some database work — you're competing with every other developer who can also do a bit of everything. That's millions of people. When supply is that large, price goes down. Simple economics.

Here's what the freelance market looks like for generalists in 2026:

Those rates are not typos. That's the reality of undifferentiated technical skill in a global marketplace. You're competing with talented developers in Bangalore, Krakow, Lagos, and Buenos Aires who can deliver the same "full-stack web app" for a fraction of your cost of living.

Generalists don't have pricing power. They're price takers, not price makers. And the AI coding tools that arrived in 2025-2026 made this worse, not better — a non-developer with Cursor can now build a basic CRUD app in an afternoon. The floor dropped out from under commodity development work.

Why Ultra-Specialists Plateau

Swinging to the opposite extreme doesn't work either. If your entire identity is "I'm the world's best at configuring Webpack 4," you've got a problem. Webpack 4 usage is declining. Your addressable market shrinks every year.

Ultra-specialists face three risks:

1. Technology obsolescence. The narrower your skill, the more vulnerable you are to that technology being replaced.
2. Market ceiling. There are only so many people who need exactly that one thing.
3. No adjacent opportunity capture. When a client needs something related but slightly different, you can't serve them. They go to someone else.

The T-Shape: Where the Money Is

The T-shaped developer model isn't new. Tim Brown from IDEO popularized it in design. But developers almost never apply it to income strategy. They should.

The horizontal bar of the T is your breadth — the adjacent skills where you're competent. You can do them. You understand the concepts. You can have an intelligent conversation about them.

The vertical bar is your depth — the one (or two) areas where you're genuinely expert. Not "I've used it on a project" expert. "I've debugged edge cases at 3am and written about it" expert.

Breadth (competent in many)
←————————————————————————————————→
  Docker  |  SQL  |  APIs  |  CI/CD  |  Testing  |  Cloud
          |       |        |         |           |
          |       |        |    Depth (expert in one)
          |       |        |         |
          |       |        |         |
          |       |   Rust + Tauri   |
          |       |  Desktop Apps    |
          |       |  Local AI Infra  |
          |       |        |

The magic happens at the intersection. "I build Rust-based desktop applications with local AI capabilities" is not a skill thousands of people have. It might be hundreds. Maybe dozens. That scarcity creates pricing power.

Real examples of T-shaped positioning that commands premium rates:

Notice what's happening in that last column. These aren't "developer" rates. They're specialist rates. And the positioning isn't a lie or a stretch — it's a true description of a real, rare skill combination.

The Unique Combination Principle

Your moat doesn't come from being the best at one thing. It comes from having a combination of skills that very few other people share.

Think of it mathematically. Say there are:

• 500,000 developers who know React well
• 50,000 developers who understand healthcare data standards
• 10,000 developers who can deploy local AI models

Any one of those is a crowded market. But:

• React + healthcare + local AI? That intersection might be 50 people worldwide.

And there are hospitals, clinics, health-tech companies, and insurance firms that need exactly that combination. They'll pay whatever it takes to find someone who doesn't need 3 months of onboarding.

Real Talk: Your "unique combination" doesn't have to be exotic. "Python + knows how commercial real estate works because of a previous career" is a devastatingly effective combination because almost no developers understand commercial real estate, and almost no real estate professionals can code. You're the translator between two worlds. Translators get paid.

Exercise: Map Your Own T-Shape

Get a piece of paper or open a text file. This takes 20 minutes. Don't overthink it.

Step 1: List your deep skills (the vertical bar)

Write down 1-3 skills where you could teach a workshop. Where you've solved non-obvious problems. Where you have opinions that differ from the default advice.

My deep skills:
1. _______________
2. _______________
3. _______________

Step 2: List your adjacent skills (the horizontal bar)

Write down 5-10 skills where you're competent but not expert. You've used them in production. You could contribute to a project using them. You could learn the deep parts if you needed to.

My adjacent skills:
1. _______________     6. _______________
2. _______________     7. _______________
3. _______________     8. _______________
4. _______________     9. _______________
5. _______________     10. ______________

Step 3: List your non-technical knowledge

This is the one most developers skip, and it's the most valuable. What do you know about from previous jobs, hobbies, education, or life experience that has nothing to do with coding?

My non-technical knowledge:
1. _______________  (e.g., "worked in logistics for 3 years")
2. _______________  (e.g., "understand accounting basics from running a small business")
3. _______________  (e.g., "fluent in German and Portuguese")
4. _______________  (e.g., "competitive cycling — understand sports analytics")
5. _______________  (e.g., "parent of special needs child — understand accessibility deeply")

Step 4: Find your intersections

Now combine items from all three lists. Write down 3-5 combinations that are unusual — that you'd be surprised to find in another person.

My unique intersections:
1. [Deep skill] + [Adjacent skill] + [Non-tech knowledge] = _______________
2. [Deep skill] + [Non-tech knowledge] = _______________
3. [Deep skill] + [Deep skill] + [Adjacent skill] = _______________

Step 5: The pricing test

For each intersection, ask: "If a company needed someone with exactly this combination, how many people could they find? And what would they have to pay?"

If the answer is "thousands of people, at commodity rates," the combination isn't specific enough. Go deeper. Add another dimension.

If the answer is "maybe 50-200 people, and they'd probably pay $150+/hr," you've found a potential moat.

Lesson 1 Checkpoint

You should now have:

• [ ] 1-3 deep skills identified
• [ ] 5-10 adjacent skills listed
• [ ] 3-5 non-technical knowledge areas documented
• [ ] 3+ unique intersection combinations written down
• [ ] A rough sense of which intersections have the fewest competitors

Keep this T-shape map. You'll combine it with your moat category in Lesson 2 to build your Moat Map in Lesson 6.

Lesson 2: The 5 Moat Categories for Developers

"There are only five kinds of walls. Know which ones you can build."

Every developer moat falls into one of five categories. Some are quick to build but easy to erode. Others take months to construct but last for years. Understanding the categories helps you choose where to invest your limited time.

Moat Category 1: Integration Moats

What it is: You connect systems that don't talk to each other. You're the bridge between two ecosystems, two APIs, two worlds that each have their own documentation, conventions, and quirks.

Why it's a moat: Nobody wants to read two sets of documentation. Seriously. If System A has 200 pages of API docs and System B has 300 pages of API docs, the person who deeply understands both and can make them work together has eliminated 500 pages of reading for every future customer. That's worth paying for.

Real examples with real revenue:

Example 1: Niche Zapier/n8n integrations

Consider this scenario: a developer builds custom Zapier integrations connecting Clio (legal practice management) with Notion, Slack, and QuickBooks. Law firms manually copy data between these systems for hours every week.

• Development time per integration: 40-80 hours
• Price: $3,000-5,000 per integration
• Ongoing maintenance retainer: $500/month
• Revenue potential in first year: $42,000 from 8 clients

The moat: understanding legal practice management workflows and speaking the language of law firm operations. Another developer could learn the Clio API, sure. But learning the API AND understanding why a law firm needs specific data to flow in a specific order at a specific time in their case lifecycle? That takes domain knowledge most developers don't have.

NOTE: For a real reference point on niche integrations, Plausible Analytics bootstrapped a privacy-first analytics tool to $3.1M ARR with 12K paying subscribers by owning one specific wedge (privacy) against a dominant incumbent (Google Analytics). Niche integration plays follow the same pattern: own the bridge nobody else bothers to build. (Source: plausible.io/blog)

Example 2: MCP servers bridging ecosystems

Here's how this plays out: a developer builds an MCP server connecting Claude Code to Pipedrive (CRM), exposing tools for deal search, stage management, and full deal context retrieval. The server takes 3 days to build.

Revenue model: $19/month per user, or $149/year. Pipedrive has 100,000+ paying companies. Even 0.1% adoption = 100 customers = $1,900/month MRR.

NOTE: This pricing model mirrors real developer tool economics. Marc Lou's ShipFast (a Next.js boilerplate) hit $528K in 4 months at a $199-249 price point by targeting a specific developer need with a focused product. (Source: starterstory.com)

Example 3: Data pipeline integration

Consider this scenario: a developer builds a service that takes data from Shopify stores and feeds it into local LLMs for product description generation, SEO optimization, and customer email personalization. The integration handles Shopify webhooks, product schema mapping, image processing, and output formatting — all locally.

• Monthly fee: $49/month per store
• 30 stores after 4 months = $1,470 MRR
• The moat: deep understanding of Shopify's data model AND local LLM deployment AND e-commerce copywriting patterns. Three domains. Very few people at that intersection.

NOTE: For real-world validation of multi-domain intersection plays, Pieter Levels runs Nomad List, PhotoAI, and other products generating roughly $3M/year with zero employees — each product sits at an intersection of technical skill and niche domain knowledge that few competitors can replicate. (Source: fast-saas.com)

How to build an integration moat:

1. Pick two systems that your target market uses together
2. Find the pain point in how they currently connect (usually: they don't, or they use CSV exports and manual copy-paste)
3. Build the bridge
4. Price based on time saved, not hours worked

Common Mistake: Building integrations between two massive platforms (like Salesforce and HubSpot) where enterprise vendors already have solutions. Go niche. Clio + Notion. Pipedrive + Linear. Xero + Airtable. The niches are where the money is because the big players don't bother.

Moat Category 2: Speed Moats

What it is: You do in 2 hours what takes agencies 2 weeks. Your tools, workflows, and expertise create a delivery speed that competitors can't match without the same investment in tooling.

Why it's a moat: Speed is hard to fake. A client can't tell if your code is better than someone else's code (not easily, anyway). But they can absolutely tell that you delivered in 3 days what the last person quoted 3 weeks for. Speed creates trust, repeat business, and referrals.

The 2026 speed advantage:

You're reading this playbook in 2026. You have access to Claude Code, Cursor, local LLMs, and a Sovereign Stack that you configured in Module S. Combined with your deep expertise, you can ship work at a pace that would have been impossible 18 months ago.

Here's the real math:

Example: The landing page speedrunner

Here's how this plays out: a freelance developer builds a reputation for delivering complete landing pages — design, copy, responsive layout, contact form, analytics, deployment — in under 6 hours, charging $1,500 per page.

Their stack:

• Claude Code for generating the initial layout and copy from a client brief
• A personal component library built over 6 months (50+ pre-built sections)
• Vercel for instant deployment
• A pre-configured analytics setup they clone for every project

An agency charges $3,000-8,000 for the same deliverable and takes 2-3 weeks because they have meetings, revisions, multiple handoffs between designer and developer, and project management overhead.

This developer: $1,500, delivered same day, client ecstatic.

Monthly revenue from landing pages alone: $6,000-9,000 (4-6 pages per month).

The moat: the component library and deployment workflow took 6 months to build. A new competitor would need those same 6 months to reach the same speed. By then, the developer has 6 months of client relationships and referrals.

NOTE: The component library approach mirrors Adam Wathan's Tailwind UI, which generated $4M+ in its first 2 years selling pre-built CSS components at $149-299. Speed moats built on reusable assets have proven economics. (Source: adamwathan.me)

How to build a speed moat:

1. Build a template/component library. Every project you do, extract the reusable parts. After 10 projects, you have a library. After 20, you have a superpower.

# Example: a project scaffolding script that saves 2+ hours per project
#!/bin/bash
# scaffold-client-project.sh

PROJECT_NAME=$1
TEMPLATE=${2:-"landing-page"}

echo "Scaffolding $PROJECT_NAME from template: $TEMPLATE"

# Clone your private template repo
git clone git@github.com:yourusername/templates-${TEMPLATE}.git "$PROJECT_NAME"
cd "$PROJECT_NAME"

# Remove git history (fresh start for client)
rm -rf .git
git init

# Configure project
sed -i "s/{{PROJECT_NAME}}/$PROJECT_NAME/g" package.json
sed -i "s/{{PROJECT_NAME}}/$PROJECT_NAME/g" src/config.ts

# Install dependencies
pnpm install

# Set up deployment
vercel link --yes

echo "Project $PROJECT_NAME is ready. Start with: pnpm run dev"
echo "Template: $TEMPLATE"
echo "Deploy with: vercel --prod"

2. Create pre-configured AI workflows. Write system prompts and agent configurations tuned for your most common tasks.

3. Automate the boring parts. If you do something more than 3 times, script it. Deployment, testing, client reporting, invoicing.

4. Demonstrate speed publicly. Record a timelapse of building something in 2 hours. Post it. Clients will find you.

Real Talk: Speed moats erode as AI tools improve and more developers adopt them. The pure speed advantage of "I use Claude Code and you don't" will shrink over the next 12-18 months as adoption spreads. Your speed moat needs to be built on top of speed — your domain knowledge, your component library, your workflow automation. The AI tools are the engine. Your accumulated systems are the transmission.

Moat Category 3: Trust Moats

What it is: You're the known expert in a specific niche. When people in that niche have a problem, your name comes up. They don't shop around. They come to you.

Why it's a moat: Trust takes time to build and is impossible to buy. A competitor can copy your code. They can undercut your price. They can't copy the fact that 500 people in a niche community know your name, have read your blog posts, and have seen you answer questions for the last 18 months.

The "3 Blog Posts" rule:

Here is one of the most underappreciated dynamics on the internet: in most micro-niches, there are fewer than 3 deep technical articles. Write 3 excellent posts about a narrow technical topic, and Google will surface them. People will read them. Within 3-6 months, you are "the person who wrote about X."

This isn't a theory. It's math. Google's index has billions of pages, but for the query "how to deploy Ollama on Hetzner with GPU passthrough for production," there might be 2-3 relevant results. Write the definitive guide and you own that query.

Example: The Rust + WebAssembly consultant

Consider this scenario: a developer writes one blog post per month about Rust + WebAssembly for 6 months. Topics include:

1. "Compiling Rust to WASM: The Complete Production Guide"
2. "WASM Performance Benchmarks: Rust vs. Go vs. C++ in 2026"
3. "Building Browser Extensions in Rust with WebAssembly"
4. "Debugging WASM Memory Leaks: The Definitive Troubleshooting Guide"
5. "Rust + WASM in Production: Lessons from Shipping to 1M Users"
6. "The WebAssembly Component Model: What It Means for Rust Developers"

Projected results after 6 months:

• Combined monthly views: ~15,000
• Inbound consulting inquiries: 4-6 per month
• Consulting rate: $300/hr (up from $150/hr before the blog)
• Monthly consulting revenue: $6,000-12,000 (20-40 billable hours)
• Speaking invitations: 2 conferences

The total time investment in writing: about 80 hours over 6 months. The ROI on those 80 hours is absurd.

NOTE: Rust developer consulting rates averaging $78/hr (up to $143/hr on the high end per ZipRecruiter data) are the baseline. Trust moat positioning pushes rates to $200-400/hr. AI/ML specialists with trust moats command $120-250/hr (Source: index.dev). The "3 blog posts" strategy works because in most micro-niches, fewer than 3 deep technical articles exist.

Building in public as a trust accelerator:

"Building in public" means sharing your work, your process, your numbers, and your decisions openly — usually on Twitter/X, but also on personal blogs, YouTube, or forums.

It works because it demonstrates three things simultaneously:

1. Competence — you can build things that work
2. Transparency — you're honest about what works and what doesn't
3. Consistency — you show up regularly

A developer who tweets about building their product every week for 6 months — showing screenshots, sharing metrics, discussing decisions — builds a following that translates directly into customers, consulting leads, and partnership opportunities.

How to build a trust moat:

The compounding effect:

Trust moats compound in a way that other moats don't. Blog post #1 gets 500 views. Blog post #6 gets 5,000 views because Google now trusts your domain AND previous posts link to new ones AND people share your content because they recognize your name.

The same dynamic applies to consulting. Client #1 hired you because of a blog post. Client #5 hired you because Client #2 referred them. Client #10 hired you because everyone in the Rust + WASM community knows your name.

Common Mistake: Waiting until you're an "expert" to start writing. You're an expert relative to 99% of people the moment you've solved a real problem. Write about it. The person who writes about the problem they solved yesterday provides more value than the theoretical expert who never publishes anything.

Moat Category 4: Data Moats

What it is: You have access to datasets, pipelines, or data-derived insights that competitors can't easily replicate. Proprietary data is one of the strongest possible moats because it's genuinely unique.

Why it's a moat: In the AI era, everyone has access to the same models. GPT-4o is GPT-4o whether you call it or your competitor does. But the data you feed those models — that's what creates differentiated output. The developer with better data produces better results, period.

Example: npm trend analytics

Here's how this plays out: a developer builds a data pipeline that tracks npm download statistics, GitHub stars, StackOverflow question frequency, and job posting mentions for every JavaScript framework and library. They run this pipeline daily for 2 years, accumulating a dataset that simply doesn't exist anywhere else in that format.

Products built on this data:

• Weekly "JavaScript Ecosystem Pulse" newsletter — $7/month, 400 subscribers = $2,800/month
• Quarterly trend reports sold to developer tool companies — $500 each, 6-8 per quarter = $3,000-4,000/quarter
• API access to raw data for researchers — $49/month, 20 subscribers = $980/month

Total monthly revenue potential: ~$4,500

The moat: replicating that data pipeline would take another developer 2 years of daily collection. The historical data is irreplaceable. You can't go back in time and collect last year's daily npm stats.

NOTE: This model mirrors real data businesses. Plausible Analytics built their competitive moat partly on being the only privacy-first analytics platform with years of accumulated operational data and trust, bootstrapping to $3.1M ARR. Data moats are the hardest to replicate because they require time, not just skill. (Source: plausible.io/blog)

How to build data moats ethically:

1. Collect public data systematically. Data that's technically public but practically unavailable (because nobody has organized it) has real value. Build a simple pipeline: SQLite database, daily cron job, GitHub API for stars/forks, npm API for downloads, Reddit API for community sentiment. Run it daily. In 6 months, you have a dataset nobody else has.

# Core pattern: daily data collection into SQLite (run via cron)
# 0 6 * * * python3 /path/to/niche_data_collector.py

import requests, json, sqlite3
from datetime import datetime

conn = sqlite3.connect("niche_data.db")
conn.execute("""CREATE TABLE IF NOT EXISTS data_points (
    id INTEGER PRIMARY KEY, source TEXT, metric_name TEXT,
    metric_value REAL, metadata TEXT, collected_at TEXT
)""")

# Collect GitHub stars for repos in your niche
for repo in ["tauri-apps/tauri", "anthropics/anthropic-sdk-python"]:
    resp = requests.get(f"https://api.github.com/repos/{repo}", timeout=10)
    if resp.ok:
        data = resp.json()
        conn.execute("INSERT INTO data_points VALUES (NULL,?,?,?,?,?)",
            ("github", repo, data["stargazers_count"],
             json.dumps({"forks": data["forks_count"]}),
             datetime.utcnow().isoformat()))

# Same pattern for npm downloads, job postings, etc.
conn.commit()

2. Create derived datasets. Take raw data and add intelligence — classifications, scores, trends, correlations — that make the data more valuable than the sum of its parts.

3. Build domain-specific corpora. A well-curated dataset of 10,000 legal contract clauses categorized by type, risk level, and jurisdiction is worth real money to legal tech companies. No clean dataset exists for most domains.

4. Time-series advantage. The data you start collecting today becomes more valuable every day because no one can go back and collect yesterday's data. Start now.

Ethics of data collection:

• Only collect publicly available data
• Respect robots.txt and rate limits
• Never scrape personal or private information
• If a site explicitly prohibits scraping, don't scrape it
• Add value through organization and analysis, not just aggregation
• Be transparent about your data sources when selling

Real Talk: Data moats are the hardest to build quickly but the hardest for competitors to replicate. A competitor can write the same blog post. They can build the same integration. They cannot replicate your 18-month dataset of daily metrics without a time machine. If you're willing to invest the upfront time, this is the strongest moat category.

Moat Category 5: Automation Moats

What it is: You've built a library of scripts, tools, and automation workflows that compound over time. Each automation you create adds to your capacity and speed. After a year, you have a toolbox that would take a competitor months to replicate.

Why it's a moat: Automation compounds. Script #1 saves you 30 minutes per week. Script #20 saves you 15 hours per week. After building 20 automations over 12 months, you can serve clients at a velocity that looks like magic from the outside. They see the result (fast delivery, low price, high quality) but not the 12 months of tooling behind it.

Example: The automation-first agency

A solo developer built a "one-person agency" serving e-commerce businesses. Over 18 months, they accumulated:

• 12 data extraction scripts (product data from various platforms)
• 8 content generation pipelines (product descriptions, SEO metadata, social posts)
• 5 reporting automations (weekly analytics summaries for clients)
• 4 deployment scripts (push updates to client stores)
• 3 monitoring bots (alert on price changes, stock issues, broken links)

Total scripts: 32. Time to build: roughly 200 hours over 18 months.

The result: this developer could onboard a new e-commerce client and have their full automation suite running within 2 days. Competitors quoted 4-6 weeks for comparable setup.

Pricing: $1,500/month retainer per client (10 clients = $15,000/month) Time per client after automation: 4-5 hours/month (monitoring and adjustments) Effective hourly rate: $300-375/hr

The moat: those 32 scripts, tested and refined across 10 clients, represent 200+ hours of development time. A new competitor starts from zero.

How to build an automation moat:

The Automation Compounding Rule:
- Month 1: You have 0 automations. You do everything manually. Slow.
- Month 3: You have 5 automations. You're 20% faster than manual.
- Month 6: You have 12 automations. You're 50% faster.
- Month 12: You have 25+ automations. You're 3-5x faster than manual.
- Month 18: You have 35+ automations. You're operating at a level that
  looks like a team of 3 to your clients.

The practical approach:

Every time you do a task for a client, ask: "Will I do this task, or something very similar, again?"

If yes:

1. Do the task manually the first time (ship the deliverable, don't delay for automation)
2. Immediately after, spend 30-60 minutes turning the manual process into a script
3. Store the script in a private repo with clear documentation
4. Next time this task comes up, run the script and save 80% of the time

Example: a client-weekly-report.sh script that pulls analytics data, pipes it through your local LLM for analysis, and generates a formatted markdown report. Takes 30 minutes to build, saves 45 minutes per client per week. Multiply by 10 clients and you've saved 7.5 hours every week from a 30-minute investment.

Common Mistake: Building automations that are too specific to one client and can't be reused. Always ask: "Can I parameterize this so it works for any client in this category?" A script that works for one Shopify store should work for any Shopify store with minimal changes.

Combining Moat Categories

The strongest positions combine multiple moat types. Here are proven combinations:

Lesson 2 Checkpoint

You should now understand:

• [ ] The five moat categories: Integration, Speed, Trust, Data, Automation
• [ ] Which categories match your current strengths and situation
• [ ] Specific examples of each moat type with real revenue numbers
• [ ] How moat categories combine for stronger positioning
• [ ] Which moat type you want to prioritize building first

Lesson 3: Niche Selection Framework

"Not every problem is worth solving. Here's how to find the ones that pay."

The 4-Question Filter

Before you invest 40+ hours into building anything, run it through these four questions. If any answer is "no," the niche probably isn't worth pursuing. If all four are "yes," you've got a candidate.

Question 1: "Would someone pay $50 to solve this problem?"

This is the minimum viable price test. Not $5. Not $10. $50. If someone wouldn't pay $50 to make this problem go away, the problem isn't painful enough to build a business around.

How to validate: Search for the problem on Google. Look at existing solutions. Are they charging at least $50? If there are no existing solutions, that's either a massive opportunity or a sign that nobody cares enough to pay. Go to forums (Reddit, HN, StackOverflow) and look for people complaining about this problem. Count the complaints. Measure the frustration.

Question 2: "Can I build a solution in under 40 hours?"

Forty hours is a reasonable first-version budget. It's one week of full-time work, or 4 weeks of 10-hour side weeks. If the minimum viable product takes longer than that, the risk-reward ratio is off for a solo developer testing a niche.

Note: 40 hours for v1. Not the polished final product. The thing that solves the core problem well enough that someone would pay for it.

With AI coding tools in 2026, your effective output during those 40 hours is 2-4x what it would have been in 2023. A 40-hour sprint in 2026 produces what used to take 100-160 hours.

Question 3: "Does this solution compound (get better or more valuable over time)?"

A freelance project that's done when it's done is income. A product that gets better with each customer, or a dataset that grows daily, or a reputation that builds with each blog post — that's a compounding asset.

Examples of compounding:

• A SaaS product gets better as you add features based on user feedback
• A data pipeline becomes more valuable as the historical dataset grows
• A template library becomes faster with each project
• A reputation grows with each piece of published content
• An automation library covers more edge cases with each client

Examples of NOT compounding:

• Custom one-off development (done when delivered, no reuse)
• Hourly consulting with no content production (time-for-money, doesn't scale)
• A tool that solves a problem that will go away (migration tools for a one-time migration)

Question 4: "Is the market growing?"

A shrinking market punishes even the best positioning. A growing market rewards even mediocre execution. You want to swim with the current, not against it.

How to check:

• Google Trends: Is search interest increasing?
• npm/PyPI downloads: Are the relevant packages growing?
• Job postings: Are companies hiring for this technology/domain?
• Conference talks: Is this topic appearing at more conferences?
• GitHub activity: Are new repos in this space getting stars?

The Niche Scoring Matrix

Score each potential niche from 1-5 on each dimension. Multiply the scores. Higher is better.

+-------------------------------------------------------------------+
| NICHE EVALUATION SCORECARD                                         |
+-------------------------------------------------------------------+
| Niche: _________________________________                           |
|                                                                    |
| PAIN INTENSITY           (1=mild annoyance, 5=hair on fire)  [  ] |
| WILLINGNESS TO PAY       (1=expects free, 5=throws money)    [  ] |
| BUILDABILITY (under 40h) (1=massive project, 5=weekend MVP)  [  ] |
| COMPOUNDING POTENTIAL    (1=one-and-done, 5=snowball effect)  [  ] |
| MARKET GROWTH            (1=shrinking, 5=exploding)           [  ] |
| PERSONAL FIT             (1=hate the domain, 5=obsessed)     [  ] |
| COMPETITION              (1=red ocean, 5=blue ocean)          [  ] |
|                                                                    |
| TOTAL SCORE (multiply all):  ___________                           |
|                                                                    |
| Maximum possible: 5^7 = 78,125                                     |
| Strong niche: 5,000+                                               |
| Viable niche: 1,000-5,000                                          |
| Weak niche: Under 1,000                                            |
+-------------------------------------------------------------------+

Worked Examples

Let's walk through four real niche evaluations.

Niche A: MCP servers for accounting software (Xero, QuickBooks)

Total: 4 x 5 x 4 x 4 x 5 x 3 x 4 = 19,200 — Strong niche.

Niche B: WordPress theme development

Total: 2 x 3 x 5 x 2 x 1 x 2 x 1 = 120 — Weak niche. Walk away.

Niche C: Local AI deployment consulting for law firms

Total: 5 x 5 x 3 x 4 x 5 x 3 x 5 = 22,500 — Very strong niche.

Niche D: General "AI chatbot" for small businesses

Total: 3 x 2 x 4 x 2 x 3 x 2 x 1 = 576 — Weak niche. The math doesn't lie.

Real Talk: The scoring matrix isn't magic. It won't guarantee success. But it WILL prevent you from spending 3 months on a niche that was obviously weak if you'd just evaluated it honestly for 15 minutes. The biggest time waster in developer entrepreneurship isn't building the wrong thing. It's building the right thing for the wrong market.

Exercise: Score 3 Niches

Take the T-shape intersections you identified in Lesson 1. Pick three possible niches that emerge from those intersections. Score each one using the matrix above. Keep the highest-scoring niche as your primary candidate. You'll validate it in Lesson 6.

Lesson 3 Checkpoint

You should now have:

• [ ] Understanding of the 4-question filter
• [ ] A completed scoring matrix for at least 3 potential niches
• [ ] A clear top candidate based on the scores
• [ ] Knowledge of what makes a niche strong vs. weak
• [ ] Honest assessment of where your candidates fall

Lesson 4: 2026-Specific Moats

"These moats exist right now because the market is new. They won't last forever. Move."

Some moats are timeless — trust, deep expertise, proprietary data. Others are time-sensitive. They exist because a new market opened, a new technology launched, or a new regulation kicked in. The developers who move first capture disproportionate value.

Here are seven moats that are uniquely available in 2026. For each one: market size estimate, competition level, entry difficulty, revenue potential, and what you can do this week to start building it.

1. MCP Server Development

What: Building Model Context Protocol servers that connect AI coding tools to external services.

Why NOW: MCP launched in late 2025. Anthropic is pushing it hard. Claude Code, Cursor, Windsurf, and other tools are integrating MCP. There are about 2,000 MCP servers today. There should be 50,000+. The gap is enormous.

How to start this week:

# Step 1: Set up the MCP SDK
mkdir my-niche-mcp && cd my-niche-mcp
npm init -y
npm install @modelcontextprotocol/sdk

# Step 2: Pick a niche API that developers use but has no MCP server
# Check: https://github.com/modelcontextprotocol/servers
# Find what's MISSING. That's your opportunity.

# Step 3: Build a basic server (2-3 days)
# Step 4: Test with Claude Code
# Step 5: Publish to npm, announce on Twitter and Reddit
# Step 6: Monetize via Pro features, hosted version, or enterprise support

Specific niches with no MCP server (as of early 2026):

• Accounting: Xero, FreshBooks, Wave
• Project management: Basecamp, Monday.com (beyond basic)
• E-commerce: WooCommerce, BigCommerce
• Healthcare: FHIR APIs, Epic EHR
• Legal: Clio, PracticePanther
• Real estate: MLS data, property management APIs
• Education: Canvas LMS, Moodle

Common Mistake: Building an MCP server for a service that already has one (like GitHub or Slack). Check the registry first. Go where there's zero or minimal coverage.

2. Local AI Deployment Consulting

What: Helping businesses run AI models on their own infrastructure.

Why NOW: The EU AI Act is now being enforced. Companies need to demonstrate data governance. Simultaneously, open-source models (Llama 3, Qwen 2.5, DeepSeek) reached quality levels that make local deployment viable for real business use. The demand for "help us run AI privately" is at an all-time high.

How to start this week:

1. Deploy Ollama on a VPS with a clean, documented setup. Photograph/screenshot your process.
2. Write a blog post: "How to Deploy a Private LLM in 30 Minutes for [Industry]"
3. Share on LinkedIn with the tagline: "Your data never leaves your servers."
4. Respond to threads on r/LocalLLaMA and r/selfhosted where people ask about enterprise deployment.
5. Offer a free 30-minute "AI infrastructure audit" to 3 businesses in your network.

3. Privacy-First SaaS

What: Building software that processes data entirely on the user's device. No cloud. No telemetry. No third-party data sharing.

Why NOW: Users are fed up with cloud services disappearing (Pocket shutdown, Google Domains shutdown, Evernote decline). Privacy regulations are tightening globally. "Local-first" went from niche ideology to mainstream demand. Frameworks like Tauri 2.0 make building local-first desktop apps dramatically easier than Electron ever was.

How to start this week:

1. Pick a cloud SaaS tool that people complain about regarding privacy
2. Search Reddit and HN for "[tool name] privacy" or "[tool name] alternative self-hosted"
3. If you find threads with 50+ upvotes asking for a private alternative, you have a market
4. Scaffold a Tauri 2.0 app with a SQLite backend
5. Build the minimum useful version (it doesn't need to match the cloud product's full feature set)

4. AI Agent Orchestration

What: Building systems where multiple AI agents collaborate to complete complex tasks — with routing, state management, error handling, and cost optimization.

Why NOW: Everyone can make one LLM call. Few people can orchestrate multi-step, multi-model, multi-tool agent workflows reliably. The tooling is immature. The patterns are still being established. The developers who master agent orchestration now will be the senior engineers of this discipline in 2-3 years.

How to start this week:

1. Build a multi-agent system for your own use (e.g., a research agent that delegates to search, summary, and writing sub-agents)
2. Document the architecture decisions and tradeoffs
3. Publish a blog post: "What I Learned Building a 4-Agent Orchestration System"
4. This is trust-moat + technical-moat combined

5. LLM Fine-Tuning for Niche Domains

What: Taking a base model and fine-tuning it on domain-specific data so it performs dramatically better than the base model for specific tasks.

Why NOW: LoRA and QLoRA made fine-tuning accessible on consumer GPUs (12GB+ VRAM). A developer with an RTX 3060 can fine-tune a 7B model on 10,000 examples in a few hours. Most businesses don't know how to do this. You do. (Note: without a dedicated GPU, you can still offer this service using cloud GPU rentals from providers like RunPod or Vast.ai — the consulting expertise is the moat, not the hardware.)

How to start this week:

# Install the tools
pip install transformers datasets peft accelerate bitsandbytes

# Get a base model
# For a 12GB GPU, start with a 7B model
ollama pull llama3.1:8b

# Prepare training data (the hard part — this is where domain knowledge matters)
# You need 500-10,000 high-quality examples of input→output for your domain
# Example for legal contract analysis:
# Input: "The Licensee shall pay a royalty of 5% of net sales..."
# Output: {"clause_type": "royalty", "percentage": 5, "basis": "net_sales"}

# Fine-tune with LoRA (using Hugging Face + PEFT)
# This runs on a 12GB GPU in 2-4 hours for 5,000 examples

6. Tauri / Desktop App Development

What: Building cross-platform desktop applications using Tauri 2.0 (Rust backend, web frontend).

Why NOW: Tauri 2.0 is mature and stable. Electron is showing its age (memory hog, security concerns). Companies are looking for lighter alternatives. The Tauri developer pool is small — maybe 10,000-20,000 active developers worldwide. Compare that to 2M+ React developers.

How to start this week:

1. Build a small Tauri app that solves a real problem (file converter, local data viewer, etc.)
2. Publish the code on GitHub
3. Write "Why I Chose Tauri Over Electron in 2026"
4. Share in the Tauri Discord and on Reddit
5. You are now one of the relatively few developers with a public Tauri portfolio

7. Developer Tooling (CLI Tools, Extensions, Plugins)

What: Building tools that other developers use in their daily workflow.

Why NOW: Developer tooling is an evergreen market, but 2026 has specific tailwinds. AI coding tools create new extension points. MCP creates a new distribution channel. Developers are willing to pay for tools that save them time now that they're more productive (the "I'm earning more per hour, so my time is worth more, so I'll pay $10/month to save 20 minutes/day" logic).

How to start this week:

1. What repetitive task do YOU do that annoys you?
2. Build a CLI tool or extension that solves it
3. If it solves it for you, it probably solves it for others
4. Ship to npm/crates.io/PyPI with a free tier and a $9/month Pro tier

// Pattern: Free CLI tool with Pro license gating
// Build the core for free, gate batch processing / advanced features behind $9/mo

use clap::Parser;

#[derive(Parser)]
#[command(name = "niche-tool", about = "Does one thing well")]
struct Cli {
    input: String,
    #[arg(short, long, default_value = "json")]
    format: String,
    #[arg(long)]  // Pro feature: batch processing
    batch: Option<String>,
}

fn main() {
    let cli = Cli::parse();
    if cli.batch.is_some() && !check_license() {
        eprintln!("Batch processing requires Pro ($9/mo): https://your-tool.dev/pro");
        std::process::exit(1);
    }
    // Free tier: single-item processing. Pro tier: batch.
}

Real Talk: Not all seven of these moats are for you. Pick one. Maybe two. The worst thing you can do is try to build all seven simultaneously. Read through them, identify which one aligns with your T-shape from Lesson 1, and focus there. You can always pivot later.

Lesson 4 Checkpoint

You should now have:

• [ ] Understanding of all seven 2026-specific moats
• [ ] 1-2 moats identified that match your T-shape and situation
• [ ] A concrete action you can take THIS WEEK to start building
• [ ] Realistic expectations about timeline and revenue for your chosen moat
• [ ] Awareness of which moats are time-sensitive (move now) vs. durable (can build over time)

Lesson 5: Competitive Intelligence (Without Being Creepy)

"Know what exists, what's broken, and where the gaps are — before you build."

Why Competitive Intelligence Matters

Most developers build first and research later. They spend 3 months building something, launch it, and then discover that 4 other tools already exist, one of them is free, and the market is smaller than they thought.

Reverse the order. Research first. Build second. Thirty minutes of competitive research can save you 300 hours of building the wrong thing.

The Research Stack

You don't need expensive tools. Everything below is free or has a generous free tier.

Tool 1: GitHub — The Supply Side

GitHub tells you what's already been built in your niche.

# Search GitHub for existing solutions in your niche
curl -s "https://api.github.com/search/repositories?q=mcp+server+accounting&sort=stars&order=desc" \
  | python3 -c "
import sys, json; data = json.load(sys.stdin)
print(f'Total results: {data[\"total_count\"]}')
for r in data['items'][:10]:
    print(f'  {r[\"full_name\"]:40} stars:{r[\"stargazers_count\"]:5}')"

# Check how active the competition is (last commit date, issue activity)
curl -s "https://api.github.com/repos/OWNER/REPO/commits?per_page=5" \
  | python3 -c "
import sys, json
for c in json.load(sys.stdin):
    print(f'  {c[\"commit\"][\"author\"][\"date\"][:10]}  {c[\"commit\"][\"message\"][:70]}')"

What to look for:

• Repos with many stars but few recent commits = abandoned opportunity. Users want it but the maintainer moved on.
• Repos with many open issues = unmet needs. Read the issues. They're a roadmap of what people want.
• Repos with few stars but recent commits = someone is trying but hasn't found product-market fit. Study their mistakes.

Tool 2: npm/PyPI/crates.io Download Trends — The Demand Side

Downloads tell you whether people are actually using solutions in your niche.

# niche_demand_checker.py — Check npm download trends for packages in your niche
import requests
from datetime import datetime, timedelta

def check_npm_downloads(package, period="last-month"):
    resp = requests.get(f"https://api.npmjs.org/downloads/point/{period}/{package}", timeout=10)
    return resp.json().get("downloads", 0) if resp.ok else 0

def check_trend(package, months=6):
    """Get monthly download trend to spot growth."""
    today = datetime.now()
    for i in reversed(range(months)):
        start = (today - timedelta(days=30*(i+1))).strftime("%Y-%m-%d")
        end = (today - timedelta(days=30*i)).strftime("%Y-%m-%d")
        resp = requests.get(f"https://api.npmjs.org/downloads/point/{start}:{end}/{package}")
        downloads = resp.json().get("downloads", 0) if resp.ok else 0
        bar = "#" * (downloads // 5000)
        print(f"  {start} to {end}  {downloads:>10,}  {bar}")

# Compare packages in your niche
for pkg in ["@modelcontextprotocol/sdk", "@anthropic-ai/sdk", "ollama", "langchain"]:
    print(f"  {pkg:40} {check_npm_downloads(pkg):>12,} downloads/month")

# Check MCP SDK growth trajectory
print("\nMCP SDK Monthly Trend:")
check_trend("@modelcontextprotocol/sdk", months=6)

Tool 3: Google Trends — The Interest Side

Google Trends shows you whether interest in your niche is growing, stable, or declining.

• Go to trends.google.com
• Search for your niche keywords
• Compare against related terms
• Filter by region if your market is geographically specific

What to look for:

• Rising trend = growing market (good)
• Flat trend = stable market (okay, if competition is low)
• Declining trend = shrinking market (avoid)
• Seasonal spikes = plan your launch timing

Tool 4: Similarweb Free — The Competition Side

For any competitor's website, Similarweb shows estimated traffic, traffic sources, and audience overlap.

• Go to similarweb.com
• Enter a competitor's domain
• Note: monthly visits, average visit duration, bounce rate, top traffic sources
• Free tier gives you enough for initial research

Tool 5: Reddit / Hacker News / StackOverflow — The Pain Side

This is where you find the actual pain points. Not what people say they want in surveys, but what they complain about at 2am when something is broken.

# pain_point_finder.py — Search Reddit for pain points in your niche
# Uses public Reddit JSON API (no auth needed for read-only)
import requests

def search_reddit(query, subreddit, limit=5):
    url = f"https://www.reddit.com/r/{subreddit}/search.json"
    params = {"q": query, "sort": "relevance", "limit": limit, "restrict_sr": "on"}
    resp = requests.get(url, params=params,
                       headers={"User-Agent": "NicheResearch/1.0"}, timeout=10)
    if not resp.ok: return []
    posts = resp.json()["data"]["children"]
    return sorted([{"title": p["data"]["title"], "score": p["data"]["score"],
                    "comments": p["data"]["num_comments"]}
                   for p in posts], key=lambda x: x["score"], reverse=True)

# Customize these queries for YOUR niche
for query, sub in [("frustrated with", "selfhosted"), ("alternative to", "selfhosted"),
                    ("how to deploy local LLM", "LocalLLaMA"), ("MCP server for", "ClaudeAI")]:
    print(f"\n=== '{query}' in r/{sub} ===")
    for r in search_reddit(query, sub):
        print(f"  [{r['score']:>4} pts, {r['comments']:>3} comments] {r['title'][:80]}")

Finding the Gaps

The research above gives you three views:

1. Supply (GitHub): What's been built
2. Demand (npm/PyPI, Google Trends): What people are looking for
3. Pain (Reddit, HN, StackOverflow): What's broken or missing

The gaps are where demand exists but supply doesn't. Or where supply exists but quality is poor.

Gap types to look for:

Building a Competitive Landscape Document

For your chosen niche, create a one-page competitive landscape. This takes 1-2 hours and saves you from building something with no market.

# Competitive Landscape: [Your Niche]
# Date: [Today]

## The Problem
[1-2 sentences describing the pain point]

## Existing Solutions

### Direct Competitors
| Solution | Price | Stars/Users | Last Updated | Strengths | Weaknesses |
|----------|-------|-------------|-------------|-----------|------------|
| [Name]   | $/mo  | count       | date        | ...       | ...        |
| [Name]   | $/mo  | count       | date        | ...       | ...        |

### Indirect Competitors (solve it differently)
| Solution | Approach | Why it's not ideal |
|----------|----------|--------------------|
| [Name]   | ...      | ...                |

### The Gap
[What's missing? What's broken? What's overpriced? What's cloud-only
but should be local? What's manual but should be automated?]

## My Positioning
[How will your solution be different? Pick ONE angle:
better, cheaper, faster, more private, more specific to a niche]

## Validation Next Steps
1. [Who will you talk to this week?]
2. [Where will you post to test demand?]
3. [What's the smallest thing you can build to prove the concept?]

How 4DA Helps with Competitive Intelligence

If you're running 4DA, you already have a competitive intelligence engine.

• Knowledge gap analysis (knowledge_gaps tool): Shows where your project's dependencies are trending, and where gaps exist in the ecosystem
• Signal classification (get_actionable_signals tool): Surfaces trending technologies and demand signals from HN, Reddit, and RSS feeds
• Topic connections (topic_connections tool): Maps relationships between technologies to find unexpected niche intersections
• Trend analysis (trend_analysis tool): Statistical patterns in your content feed that reveal emerging opportunities

The difference between manual competitive research and having 4DA running continuously is the difference between checking the weather once and having a radar. Both useful. The radar catches things you'd miss.

4DA Integration: Set up 4DA to track content from the subreddits, HN threads, and GitHub topics relevant to your chosen niche. Within a week, you'll see patterns in what people are asking for, complaining about, and building. That's your opportunity radar running 24/7.

Exercise: Research Your Top Niche

Take your highest-scoring niche from Lesson 3. Spend 90 minutes doing the research outlined above. Fill out the competitive landscape document. If the research reveals that the gap is smaller than you thought, go back to your second-highest scoring niche and research that.

The goal is not to find a niche with zero competition. That probably means zero demand. The goal is to find a niche with demand that outpaces the current supply of quality solutions.

Lesson 5 Checkpoint

You should now have:

• [ ] GitHub search results for existing solutions in your niche
• [ ] Download/adoption trends for relevant packages
• [ ] Google Trends data for your niche keywords
• [ ] Reddit/HN pain point evidence (bookmarked threads)
• [ ] A completed competitive landscape document for your top niche
• [ ] Identified gaps: what exists but is broken, what's missing entirely

Lesson 6: Your Moat Map

"A moat without a map is just a ditch. Document it. Validate it. Execute on it."

What Is a Moat Map?

Your Moat Map is the deliverable for this module. It combines everything from Lessons 1-5 into a single document that answers: "What is my defensible position in the market, and how will I build and maintain it?"

It's not a business plan. It's not a pitch deck. It's a working document that tells you:

• Who you are (T-shape)
• What your walls are (moat categories)
• Where you're fighting (niche)
• Who else is in the arena (competitive landscape)
• What you're building this quarter (action plan)

The Moat Map Template

Copy this template. Fill in every section. This is your second key deliverable. (Your Sovereign Stack Document from Module S will complement this — complete both for a full positioning foundation.)

# MOAT MAP
# [Your Name / Business Name]
# Created: [Date]
# Last Updated: [Date]

---

## 1. MY T-SHAPE

### Deep Expertise (the vertical bar)
1. [Primary deep skill] — [years of experience, notable accomplishments]
2. [Secondary deep skill, if applicable] — [years, accomplishments]

### Adjacent Skills (the horizontal bar)
1. [Skill] — [competency level: Competent / Strong / Growing]
2. [Skill] — [competency level]
3. [Skill] — [competency level]
4. [Skill] — [competency level]
5. [Skill] — [competency level]

### Non-Technical Knowledge
1. [Domain / industry / life experience]
2. [Domain / industry / life experience]
3. [Domain / industry / life experience]

### My Unique Intersection
[1-2 sentences describing the combination of skills and knowledge that
very few other people share. This is your core positioning.]

Example: "I combine deep Rust systems programming with 4 years of
healthcare industry experience and strong knowledge of local AI
deployment. I estimate fewer than 100 developers worldwide share this
specific combination."

---

## 2. MY PRIMARY MOAT TYPE

### Primary: [Integration / Speed / Trust / Data / Automation]
[Why this moat type? How does it leverage your T-shape?]

### Secondary: [A second moat type you're building]
[How does this complement the primary?]

### How They Compound
[Describe how your primary and secondary moats reinforce each other.
Example: "My trust moat (blog posts) drives inbound leads, and my
speed moat (automation library) lets me deliver faster, which creates
more trust."]

---

## 3. MY NICHE

### Niche Definition
[Complete this sentence: "I help [specific audience] with [specific problem]
by [your specific approach]."]

Example: "I help mid-size law firms deploy private AI document analysis
by setting up on-premise LLM infrastructure that never sends client
data to external servers."

### Niche Scorecard
| Dimension | Score (1-5) | Notes |
|-----------|-------------|-------|
| Pain Intensity | | |
| Willingness to Pay | | |
| Buildability (under 40h) | | |
| Compounding Potential | | |
| Market Growth | | |
| Personal Fit | | |
| Competition | | |
| **Total (multiply)** | **___** | |

### Why This Niche, Why Now
[2-3 sentences on the specific 2026 conditions that make this niche
attractive right now. Reference the 2026-specific moats from Lesson 4
if applicable.]

---

## 4. COMPETITIVE LANDSCAPE

### Direct Competitors
| Competitor | Price | Users/Traction | Strengths | Weaknesses |
|-----------|-------|---------------|-----------|------------|
| | | | | |
| | | | | |
| | | | | |

### Indirect Competitors
| Solution | Approach | Why It Falls Short |
|----------|----------|--------------------|
| | | |
| | | |

### The Gap I'm Filling
[What specifically is missing, broken, overpriced, or inadequate about
existing solutions? This is your wedge into the market.]

### My Differentiation
[Pick ONE primary differentiator. Not three. One.]
- [ ] Faster
- [ ] Cheaper
- [ ] More private / local-first
- [ ] More specific to my niche
- [ ] Better quality
- [ ] Better integrated with [specific tool]
- [ ] Other: _______________

---

## 5. REVENUE MODEL

### How I'll Get Paid
[Choose your primary revenue model. You can add secondary models later,
but start with ONE.]

- [ ] Product: One-time purchase ($_____)
- [ ] Product: Monthly subscription ($___/month)
- [ ] Service: Consulting ($___/hour)
- [ ] Service: Fixed-price projects ($____ per project)
- [ ] Service: Monthly retainer ($___/month)
- [ ] Content: Course / digital product ($_____)
- [ ] Content: Paid newsletter ($___/month)
- [ ] Hybrid: ________________

### Pricing Rationale
[Why this price? What are competitors charging? What value does it
create for the customer? Use the "10x rule": your price should be
less than 1/10th of the value you create.]

### First Dollar Target
- **What I'll sell first:** [Specific offering]
- **To whom:** [Specific person or company type]
- **At what price:** $[Specific number]
- **By when:** [Specific date, within 30 days]

---

## 6. 90-DAY MOAT-BUILDING PLAN

### Month 1: Foundation
- Week 1: _______________
- Week 2: _______________
- Week 3: _______________
- Week 4: _______________
**Month 1 milestone:** [What's true at the end of month 1 that isn't true today?]

### Month 2: Traction
- Week 5: _______________
- Week 6: _______________
- Week 7: _______________
- Week 8: _______________
**Month 2 milestone:** [What's true at the end of month 2?]

### Month 3: Revenue
- Week 9: _______________
- Week 10: _______________
- Week 11: _______________
- Week 12: _______________
**Month 3 milestone:** [Revenue target and validation criteria]

### Kill Criteria
[Under what conditions will you abandon this niche and try another?
Be specific. "If I can't get 3 people to say 'I'd pay for that' within
30 days, I'll pivot to my second-choice niche."]

---

## 7. MOAT MAINTENANCE

### What Erodes My Moat
[What could weaken your competitive position?]
1. [Threat 1] — [How you'll monitor for it]
2. [Threat 2] — [How you'll respond]
3. [Threat 3] — [How you'll adapt]

### What Strengthens My Moat Over Time
[What activities compound your advantage?]
1. [Activity] — [Frequency: daily/weekly/monthly]
2. [Activity] — [Frequency]
3. [Activity] — [Frequency]

---

*Review this document monthly. Update on the 1st of each month.
If your niche score drops below 1,000 on re-evaluation, it's time
to consider pivoting.*

A Completed Example

Here's how your Moat Map might look when filled in. This is a template example — use it as a reference for the level of specificity expected.

[Your Name] — [Your Business Name]

• T-Shape: Deep in Rust + local AI deployment. Adjacent: TypeScript, Docker, tech writing. Non-tech: 2 years working IT at a law firm.
• Unique Intersection: "Rust + local AI + law firm operations. Fewer than 50 devs worldwide share this."
• Primary Moat: Integration (connecting Ollama to legal practice management tools like Clio)
• Secondary Moat: Trust (monthly blog posts about AI in legal tech)
• Niche: "I help mid-size law firms (10-50 attorneys) deploy private AI document analysis. Client data never leaves their servers."
• Niche Score: Pain 5, WTP 5, Buildability 3, Compounding 4, Growth 5, Fit 4, Competition 5 = 7,500 (strong)
• Competitors: Harvey AI (cloud-only, expensive), CoCounsel ($250/user/mo, cloud), generic freelancers (no legal knowledge)
• Gap: No solution combines local AI + legal PMS integration + legal workflow understanding
• Differentiation: Privacy / local-first (data never leaves the firm)
• Revenue: Fixed-price deployments ($5,000-15,000) + monthly retainers ($1,000-2,000)
• Pricing rationale: 40 attorneys x $300/hr x 2 hrs/week saved = $24,000/week in recovered billable time. $10,000 deployment pays for itself in 3 days.
• First dollar: "Private AI Document Analysis Pilot" for former employer, $5,000, by March 15
• 90-day plan:
  • Month 1: Publish blog post, build reference deployment, contact 5 firms, deliver free audits
  • Month 2: Deliver pilot, write case study, contact 10 more firms, get referrals
  • Month 3: Deliver 2-3 more projects, convert 1 to retainer, launch Clio MCP server as product
  • Target: $15,000+ total revenue by day 90
• Kill criteria: If no firm agrees to paid pilot within 45 days, pivot to healthcare
• Moat maintenance: Monthly blog posts (trust), template library after every project (speed), anonymized benchmarks (data)

Validating Your Moat

Your Moat Map is a hypothesis. Before you invest 3 months into executing it, validate the core assumption: "People will pay for this."

The 3-Person Validation Method:

1. Identify 5-10 people who fit your target audience
2. Reach out to them directly (email, LinkedIn, community forum)
3. Describe your offering in 2-3 sentences
4. Ask: "If this existed, would you pay $[your price] for it?"
5. If at least 3 out of 5 say yes (not "maybe" — yes), your niche is validated

The "landing page" validation:

1. Create a single-page website describing your offering (2-3 hours with AI tools)
2. Include a price and a "Get Started" or "Join Waitlist" button
3. Drive traffic to it (post in relevant communities, share on social media)
4. If people click the button and enter their email, the demand is real

What "no" looks like and what to do about it:

• "That's interesting, but I wouldn't pay for it." → The pain isn't strong enough. Find a more acute problem.
• "I'd pay for it, but not $[your price]." → Price is wrong. Adjust downward or add more value.
• "Someone else already does this." → You have a competitor you missed. Research them and differentiate.
• "I don't understand what this is." → Your positioning is unclear. Rewrite the description.
• Radio silence (no response) → Your target audience doesn't hang out where you looked. Find them elsewhere.

Common Mistake: Asking friends and family for validation. They'll say "great idea!" because they love you, not because they'd buy it. Ask strangers who fit your target audience. Strangers have no reason to be polite. Their honest feedback is worth 100x more than your mom's encouragement.

Exercise: Complete Your Moat Map

Set a timer for 90 minutes. Copy the template above and fill in every section. Use the data from your T-shape analysis (Lesson 1), moat category selection (Lesson 2), niche scoring (Lesson 3), 2026 moat opportunities (Lesson 4), and competitive research (Lesson 5).

Don't aim for perfection. Aim for completeness. A rough but complete Moat Map is infinitely more useful than a perfect but half-finished one.

When you're done, start the validation process immediately. Contact 3-5 potential customers this week.

Lesson 6 Checkpoint

You should now have:

• [ ] A complete Moat Map document saved alongside your Sovereign Stack Document
• [ ] All 7 sections filled in with real data (not aspirational projections)
• [ ] A 90-day execution plan with specific weekly actions
• [ ] Kill criteria defined (when to pivot, when to persist)
• [ ] A validation plan: 3-5 people to contact this week
• [ ] A date set for your first monthly Moat Map review (30 days from now)

Module T: Complete

What You've Built in Two Weeks

Look at what you now have:

1. A T-shaped skill profile that identifies your unique value in the market — not just "what you know" but "what combination of knowledge makes you rare."

2. Understanding of the five moat categories and a clear choice about which type of wall you're building. Integration, Speed, Trust, Data, or Automation — you know which one leverages your strengths.

3. A validated niche selected through a rigorous scoring framework, not gut feeling. You've done the math. You know the pain intensity, the willingness to pay, and the competition level.

4. 2026-specific opportunity awareness — you know which moats are available right now because the market is new, and you know the window won't stay open forever.

5. A competitive landscape document based on real research. You know what exists, what's broken, and where the gaps are.

6. A Moat Map — your personal positioning document that combines all of the above into an actionable plan with a 90-day timeline and clear kill criteria.

This is the document most developers never create. They jump straight from "I have skills" to "I'll build something" without the critical middle step of "What should I build, for whom, and why will they choose me?"

You've done the work. You have the map. Now you need the engines.

What Comes Next: Module R — Revenue Engines

Module T told you where to aim. Module R gives you the weapons.

Module R covers:

• 8 specific revenue engine playbooks — complete with code templates, pricing guides, and launch sequences for each engine type (digital products, SaaS, consulting, content, automation services, API products, templates, and education)
• Build-along projects — step-by-step instructions for building real, revenue-generating products in your niche
• Pricing psychology — how to price your offerings for maximum revenue without scaring away customers
• Launch sequences — the exact steps for going from "built" to "sold" for each revenue engine type
• Financial modeling — spreadsheets and calculators for projecting revenue, costs, and profitability

Module R is weeks 5-8 and it's the densest module in STREETS. It's where the actual money gets made.

The Full STREETS Roadmap

4DA Integration

Your Moat Map is a snapshot. 4DA makes it a living radar.

Use developer_dna to see your actual tech identity — not what you think your skills are, but what your codebase, your project structure, and your tool usage reveal about your real strengths. This is built from scanning your actual projects, not self-reported surveys.

Use knowledge_gaps to find niches where demand exceeds supply. When 4DA shows you that a technology has growing adoption but few quality resources or tooling, that's your signal to build.

Use get_actionable_signals to monitor your niche daily. When a new competitor appears, when demand shifts, when a regulation changes — 4DA classifies content into tactical and strategic signals with priority levels, surfacing what matters before your competitors notice.

Use semantic_shifts to detect when technologies move from experimental to production adoption. This is the timing signal for your 2026-specific moats — knowing when a technology crosses the threshold from "interesting" to "companies are hiring for this" tells you when to build.

Your Sovereign Stack Document (Module S) + your Moat Map (Module T) + 4DA's continuous intelligence = a positioning system that's always on.

You've built the foundation. You've identified your moat. Now it's time to build the engines that turn positioning into revenue.

Module R starts next week. Bring your Moat Map. You'll need it.

Your rig. Your rules. Your revenue.