Module E: Evolving Edge

STREETS Developer Income Playbook (2026 Edition) Week 11 | 6 Lessons | Deliverable: Your 2026 Opportunity Radar

"This module updates every January. What worked last year may not work this year."

This module is different from every other module in STREETS. The other six modules teach principles — they age slowly. This one teaches timing — it expires fast.

Every January, this module gets rewritten from scratch. The 2025 edition talked about prompt engineering marketplaces, GPT wrapper apps, and the early MCP specification. Some of that advice would lose you money today. The wrapper apps got commoditized. The prompt marketplaces collapsed. MCP exploded in a direction nobody predicted.

That's the point. Markets move. The developer who reads last year's playbook and follows it verbatim is the developer who arrives six months late to every opportunity.

This is the 2026 edition. It reflects what is actually happening right now — February 2026 — based on real market signals, real pricing data, and real adoption curves. By January 2027, parts of this will be obsolete. That's not a flaw. That's the design.

Here's what you'll have by the end of this module:

• A clear picture of the 2026 landscape and why it's different from 2025
• Seven specific opportunities ranked by entry difficulty, revenue potential, and timing
• A framework for knowing when to enter and exit a market
• A working intelligence system that surfaces opportunities automatically
• A strategy for skill-proofing your income against future shifts
• Your completed 2026 Opportunity Radar — the three bets you're making this year

No predictions. No hype. Just signal.

Let's go.

Lesson 1: The 2026 Landscape — What Changed

"The ground shifted. If your playbook is from 2024, you're standing on air."

Six Shifts That Changed Developer Income

Every year has a handful of changes that actually matter for how developers make money. Not "interesting trends" — structural shifts that open or close income streams. In 2026, there are six.

Shift 1: Local LLMs Crossed the "Good Enough" Threshold

This is the big one. In 2024, local LLMs were a novelty — fun to tinker with, not reliable enough for production. In 2025, they got close. In 2026, they crossed the line.

What "good enough" means in practice:

The models that matter:

• Llama 3.3 (8B, 70B): Meta's workhorse. The 8B runs on anything. The 70B is GPT-3.5 quality at zero marginal cost on a 24GB card.
• Mistral Large 2 (123B) and Mistral Nemo (12B): Best-in-class for European languages. The Nemo model punches well above its weight at 12B.
• Qwen 2.5 (7B-72B): Alibaba's open-weight family. Excellent for coding tasks. The 32B version is a sweet spot — near-GPT-4 quality on structured output.
• DeepSeek V3 (distilled variants): The cost-efficiency king. Distilled models run locally and handle reasoning tasks that stumped everything else at this size a year ago.
• Phi-3.5 / Phi-4 (3.8B-14B): Microsoft's small models. Surprisingly capable for their size. The 14B model is competitive with much larger open models on coding benchmarks.

Why this matters for income:

Even without a dedicated GPU, CPU-based inference with smaller models (3B-8B) is viable for many revenue-generating tasks. A GPU upgrade would unlock the full range of opportunities below.

The cost equation flipped. In 2024, if you built an AI-powered service, your largest ongoing cost was API calls. At $5-15 per million tokens, your margins depended on how efficiently you could use the API. Now, for 80% of tasks, you can run inference locally at effectively zero marginal cost. Your only costs are electricity (~$0.003 per million tokens) and the hardware you already own.

This means:

1. Higher margins on AI-powered services (processing costs dropped 99%)
2. More products are viable (ideas that were unprofitable at API prices now work)
3. Privacy is free (no trade-off between local processing and quality)
4. You can experiment freely (no API bill anxiety while prototyping)

# Verify this on your own hardware right now
ollama pull qwen2.5:14b
time ollama run qwen2.5:14b "Write a professional cold email to a CTO about deploying local AI infrastructure. Include 3 specific benefits. Keep it under 150 words." --verbose

# Check your tokens/second in the output
# If you're above 20 tok/s, you can build production services on this model

Real Talk: "Good enough" doesn't mean "as good as Claude Opus or GPT-4o." It means good enough for the specific task you're billing a client for. A local 13B model writing email subject lines, classifying support tickets, or extracting data from invoices is indistinguishable from a cloud model for those tasks. Stop waiting for local models to match frontier models on everything. They don't need to. They need to match on YOUR use case.

Shift 2: MCP Created a New App Ecosystem

Model Context Protocol went from a specification announcement in late 2024 to an ecosystem of thousands of servers by early 2026. This happened faster than anyone predicted.

What MCP is (the 30-second version):

MCP is a standard protocol that lets AI tools (Claude Code, Cursor, Windsurf, etc.) connect to external services through "servers." An MCP server exposes tools, resources, and prompts that an AI assistant can use. Think of it as USB for AI — a universal connector that lets any AI tool talk to any service.

The current state (February 2026):

MCP Servers published:           ~4,000+
MCP Servers with 100+ users:     ~400
MCP Servers generating revenue:  ~50-80
Average revenue per paid server: $800-2,500/month
Dominant hosting:                npm (TypeScript), PyPI (Python)
Central marketplace:             None yet (this is the opportunity)

Why this is the App Store moment:

When Apple launched the App Store in 2008, the first developers who published useful apps made outsized returns — not because they were better engineers, but because they were early. The app ecosystem hadn't been built yet. Demand vastly outstripped supply.

MCP is in the same phase. Developers using Claude Code and Cursor need MCP servers for:

• Connecting to their company's internal tools (Jira, Linear, Notion, custom APIs)
• Processing files in specific formats (medical records, legal documents, financial statements)
• Accessing niche data sources (industry databases, government APIs, research tools)
• Automating workflows (deployment, testing, monitoring, reporting)

Most of these servers don't exist yet. The ones that do exist are often poorly documented, unreliable, or missing key features. The bar for "the best MCP server for X" is remarkably low right now.

Here's a basic MCP server to show how accessible this is:

// mcp-server-example/src/index.ts
// A simple MCP server that analyzes package.json dependencies
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { readFileSync, existsSync } from "fs";
import { join } from "path";

const server = new McpServer({
  name: "dependency-analyzer",
  version: "1.0.0",
});

server.tool(
  "analyze_dependencies",
  "Analyze a project's dependencies for security, freshness, and cost implications",
  {
    project_path: z.string().describe("Path to the project root"),
  },
  async ({ project_path }) => {
    const pkgPath = join(project_path, "package.json");
    if (!existsSync(pkgPath)) {
      return {
        content: [{ type: "text", text: "No package.json found at " + pkgPath }],
      };
    }

    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
    const deps = Object.entries(pkg.dependencies || {});
    const devDeps = Object.entries(pkg.devDependencies || {});

    const analysis = {
      total_dependencies: deps.length,
      total_dev_dependencies: devDeps.length,
      dependencies: deps.map(([name, version]) => ({
        name,
        version,
        pinned: !String(version).startsWith("^") && !String(version).startsWith("~"),
      })),
      unpinned_count: deps.filter(([_, v]) => String(v).startsWith("^") || String(v).startsWith("~")).length,
      recommendation: deps.length > 50
        ? "High dependency count. Consider auditing for unused packages."
        : "Dependency count is reasonable.",
    };

    return {
      content: [{
        type: "text",
        text: JSON.stringify(analysis, null, 2),
      }],
    };
  }
);

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
}

main().catch(console.error);

# Package and publish
npm init -y
npm install @modelcontextprotocol/sdk zod
npx tsc --init
# ... build and publish to npm
npm publish

That's a publishable MCP server. It took 50 lines of actual logic. The ecosystem is young enough that useful servers this simple are genuinely valuable.

Shift 3: AI Coding Tools Made Developers 2-5x More Productive

This isn't hype — it's measurable. Claude Code, Cursor, and Windsurf fundamentally changed how fast a solo developer can ship.

The real productivity multipliers:

What this means for income:

The project that took you a weekend now takes an evening. The MVP that took a month now takes a week. This is pure leverage — the same 10-15 hours per week of side work now produces 2-5x more output.

But here's what most people miss: the multiplier applies to your competitors too. If everyone can ship faster, the advantage goes to developers who ship the right thing, not just any thing. Speed is table stakes. Taste, timing, and positioning are the differentiators.

Common Mistake: Assuming AI coding tools replace the need for deep expertise. They don't. They amplify whatever skill level you bring. A senior developer using Claude Code produces senior-quality code faster. A junior developer using Claude Code produces junior-quality code faster — including junior-quality architectural decisions, junior-quality error handling, and junior-quality security practices. The tools make you faster, not better. Invest in getting better.

Shift 4: Privacy Regulations Created Real Demand

This stopped being theoretical in 2026.

EU AI Act enforcement timeline (where we are now):

Feb 2025: Prohibited AI practices banned (enforcement active)
Aug 2025: GPAI model obligations took effect
Feb 2026: ← WE ARE HERE — Full transparency obligations active
Aug 2026: High-risk AI system requirements fully enforced

The February 2026 milestone matters because companies must now document their AI data processing pipelines. Every time a company sends employee data, customer data, or proprietary code to a cloud AI provider, that's a data processing relationship that needs documentation, risk assessment, and compliance review.

Real-world impact on developer income:

• Legal firms can't send client documents to ChatGPT. They need local alternatives. Budget: $5,000-50,000 for setup.
• Healthcare companies need AI for clinical notes but can't send patient data to external APIs. Budget: $10,000-100,000 for HIPAA-compliant local deployment.
• Financial institutions want AI-assisted code review but their security teams vetoed all cloud AI providers. Budget: $5,000-25,000 for on-premise deployment.
• EU companies of all sizes are realizing that "we use OpenAI" is now a compliance liability. They need alternatives. Budget: varies, but they're actively looking.

"Local-first" went from a nerdy preference to a compliance requirement. If you know how to deploy models locally, you have a skill that enterprises will pay premium rates for.

Shift 5: "Vibe Coding" Went Mainstream

The term "vibe coding" — coined to describe non-developers building apps with AI assistance — went from a meme to a movement in 2025-2026. Millions of product managers, designers, marketers, and entrepreneurs are now building software with tools like Bolt, Lovable, v0, Replit Agent, and Claude Code.

What they're building:

• Internal tools and dashboards
• Landing pages and marketing sites
• Simple CRUD apps
• Chrome extensions
• Automation workflows
• Mobile prototypes

Where they hit walls:

• Authentication and user management
• Database design and data modeling
• Deployment and DevOps
• Performance optimization
• Security (they don't know what they don't know)
• Anything that requires understanding systems, not just syntax

The opportunity this creates for real developers:

1. Infrastructure products — They need auth solutions, database wrappers, deployment tools that "just work." Build those.
2. Education — They need guides written for people who understand products but not systems. Teach them.
3. Rescue consulting — They build something that almost works, then need a real developer to fix the last 20%. That's $100-200/hr work.
4. Templates and starters — They need starting points that handle the hard parts (auth, payments, deployment) so they can focus on the easy parts (UI, content, business logic). Sell those.

Vibe coding didn't make developers obsolete. It created a new customer segment: semi-technical builders who need developer-quality infrastructure served in non-developer-complexity packages.

Shift 6: The Developer Tool Market Grew 40% Year-over-Year

The number of professional developers worldwide hit approximately 30 million in 2026. The tools they use — IDEs, deployment platforms, monitoring, testing, CI/CD, databases — grew into a market worth over $45 billion.

More developers means more tools means more niches means more opportunities for indie builders.

The niches that opened up in 2025-2026:

• AI agent monitoring and observability
• MCP server management and hosting
• Local model evaluation and benchmarking
• Privacy-first analytics alternatives
• Developer workflow automation
• AI-assisted code review and documentation

Each niche has room for 3-5 successful products. Most have 0-1 right now.

The Compounding Effect

Here's why 2026 is exceptional. Each shift above would be significant alone. Together, they compound:

Local LLMs are production-ready
    × AI coding tools make you 5x faster at building
    × MCP created a new distribution channel
    × Privacy regulations created buyer urgency
    × Vibe coding created new customer segments
    × Growing developer population expands every market

= The largest window for developer independent income since the App Store era

This window won't stay open forever. When major players build the MCP marketplace, when privacy consulting gets commoditized, when vibe coding tools mature enough to not need developer help — the early-mover advantage shrinks. The time to position is now.

Your Turn

1. Audit your 2025 assumptions. What did you believe about AI, markets, or opportunities a year ago that's no longer true? Write down three things that changed.
2. Map the shifts to your skills. For each of the six shifts above, write one sentence about how it affects YOUR situation. Which shifts are tailwinds for you? Which are headwinds?
3. Test one local model. If you haven't run a local model in the last 30 days, pull qwen2.5:14b and give it a real task from your work. Not a toy prompt — a real task. Note the quality. Is it "good enough" for any of your income ideas?

Lesson 2: The 7 Hottest Opportunities of 2026

"Opportunity without specificity is just inspiration. Here are the specifics."

For each opportunity below, you get: what it is, the current market, competition level, entry difficulty, revenue potential, and a "Start This Week" action plan. These aren't abstract — they're executable.

For senior developers (8+ years): Opportunities 3 (Local AI Deployment Services), 4 (Fine-Tuning-as-a-Service), and 6 (Compliance Automation) are your highest-leverage plays. These are markets where expertise commands premium rates and clients specifically seek experienced practitioners. Consider combining one of these with Opportunity 7 (Developer Education) — your experience is the content. A senior developer teaching what they've learned over a decade is worth far more than a junior developer synthesizing blog posts.

Opportunity 1: MCP Server Marketplace

The App Store moment for AI tools.

What it is: Building, curating, and hosting MCP servers that connect AI coding tools to external services. This can be the servers themselves OR the marketplace that distributes them.

Market size: Every developer using Claude Code, Cursor, or Windsurf needs MCP servers. That's roughly 5-10 million developers in early 2026, growing 100%+ annually. Most have installed 0-3 MCP servers. They would install 10-20 if the right ones existed.

Competition: Very low. There's no central marketplace yet. Smithery.ai is the closest, but it's early-stage and focused on listing, not hosting or quality curation. npm and PyPI serve as de facto distribution but with zero discoverability for MCP specifically.

Entry difficulty: Low for individual servers (a useful MCP server is 100-500 lines of code). Medium for a marketplace (requires curation, quality standards, hosting infrastructure).

Revenue potential:

Start This Week:

# Day 1-2: Build your first MCP server that solves a real problem
# Pick something YOU need — that's usually what others need too

# Example: An MCP server that checks npm package health
mkdir mcp-package-health && cd mcp-package-health
npm init -y
npm install @modelcontextprotocol/sdk zod node-fetch

# Day 3-4: Test it with Claude Code or Cursor
# Add it to your claude_desktop_config.json or .cursor/mcp.json

# Day 5: Publish to npm
npm publish

# Day 6-7: Build two more servers. Publish them. Write a blog post.
# "I built 3 MCP servers this week — here's what I learned"

The person who has published 10 useful MCP servers in February 2026 will have a significant advantage over the person who publishes their first one in September 2026. First-mover matters here. Quality matters more. But showing up matters most.

Opportunity 2: Local AI Consulting

Enterprises want AI but can't send data to OpenAI.

What it is: Helping companies deploy LLMs on their own infrastructure — on-premise servers, private cloud, or air-gapped environments. This includes model selection, deployment, optimization, security hardening, and ongoing maintenance.

Market size: Every company with sensitive data that wants AI capabilities. Legal firms, healthcare organizations, financial institutions, government contractors, EU-based companies of any size. The Total Addressable Market is enormous, but more importantly, the Serviceable Addressable Market — companies actively looking for help right now — is growing monthly as EU AI Act milestones hit.

Competition: Low. Most AI consultants push cloud solutions (OpenAI/Azure/AWS) because that's what they know. The pool of consultants who can deploy Ollama, vLLM, or llama.cpp in a production environment with proper security, monitoring, and compliance documentation is tiny.

Entry difficulty: Medium. You need genuine expertise in model deployment, Docker/Kubernetes, networking, and security. Note: consulting clients will have their own hardware — you don't need a powerful GPU to advise on deployment, but having one to demo with helps close deals.

But if you've completed Module S of STREETS and you can deploy Ollama in production, you already have more practical expertise than 95% of the people calling themselves "AI consultants."

Revenue potential:

A single enterprise client on a $2,000/month retainer with occasional project work can be worth $30,000-50,000 per year. You need 2-3 of these to replace a full-time salary.

Start This Week:

1. Write a blog post: "How to Deploy Llama 3.3 for Enterprise Use: A Security-First Guide." Include actual commands, actual configuration, actual security considerations. Make it the best guide on the internet for this topic.
2. Post it on LinkedIn with the tag line: "If your company wants AI but your security team won't approve sending data to OpenAI, there's another way."
3. DM 10 CTOs or VPs of Engineering at mid-size companies (100-1000 employees) in regulated industries. Say: "I help companies deploy AI on their own infrastructure. No data leaves your network. Would a 15-minute call be useful?"

That sequence — write expertise, publish expertise, reach out to buyers — is the entire consulting sales motion.

Real Talk: "I don't feel like an expert" is the most common objection I hear. Here's the truth: if you can SSH into a Linux server, install Ollama, configure it for production, set up a reverse proxy with TLS, and write a basic monitoring script — you know more about local AI deployment than 99% of CTOs. Expertise is relative to your audience, not absolute. A hospital CTO doesn't need someone who published an AI research paper. They need someone who can make the models work securely on their hardware. That's you.

Opportunity 3: AI Agent Templates

Claude Code subagents, custom workflows, and automation packs.

What it is: Pre-built agent configurations, workflow templates, CLAUDE.md files, custom commands, and automation packs for AI coding tools.

Market size: Every developer using an AI coding tool is a potential customer. Most are using these tools at 10-20% of their capability because they haven't configured them. The gap between "default Claude Code" and "Claude Code with a well-designed agent system" is massive — and most people don't even know the gap exists.

Competition: Very low. Agents are new. Most developers are still figuring out basic prompting. The market for pre-built agent configurations barely exists.

Entry difficulty: Low. If you've built effective workflows for your own development process, you can package and sell them. The hard part isn't coding — it's knowing what makes a good agent workflow.

Revenue potential:

Example products people would buy today:

# "The Rust Agent Pack" — $39

Includes:
- Code review agent (checks unsafe blocks, error handling, lifetime issues)
- Refactoring agent (identifies and fixes common Rust anti-patterns)
- Test generation agent (writes comprehensive tests with edge cases)
- Documentation agent (generates rustdoc with examples)
- Performance audit agent (identifies allocation hotspots, suggests zero-copy alternatives)

Each agent includes:
- CLAUDE.md rules file
- Custom slash commands
- Example workflows
- Configuration guide

# "The Full-Stack Launch Kit" — $49

Includes:
- Project scaffolding agent (generates entire project structure from requirements)
- API design agent (designs REST/GraphQL APIs with OpenAPI spec output)
- Database migration agent (generates and reviews migration files)
- Deployment agent (configures CI/CD for Vercel/Railway/Fly.io)
- Security audit agent (checks OWASP top 10 against your codebase)
- Launch checklist agent (pre-launch verification across 50+ items)

Start This Week:

1. Package your current Claude Code or Cursor configuration. Whatever CLAUDE.md files, custom commands, and workflows you use — clean them up and document them.
2. Create a simple landing page (Vercel + a template, 30 minutes).
3. List it on Gumroad or Lemon Squeezy at $19-29.
4. Post about it where developers congregate: Twitter/X, Reddit r/ClaudeAI, HN Show, Dev.to.
5. Iterate based on feedback. Ship v2 within a week.

Opportunity 4: Privacy-First SaaS

The EU AI Act turned "local-first" into a compliance checkbox.

What it is: Building software that processes data entirely on the user's machine, with no cloud dependency for the core functionality. Desktop apps (Tauri, Electron), local-first web apps, or self-hosted solutions.

Market size: Every company that handles sensitive data AND wants AI capabilities. In the EU alone, that's millions of businesses newly motivated by regulation. In the US, healthcare (HIPAA), finance (SOC 2/PCI DSS), and government (FedRAMP) create similar pressure.

Competition: Moderate and growing, but the vast majority of SaaS products are still cloud-first. The "local-first with AI" niche is genuinely small. Most developers default to cloud architecture because it's what they know.

Entry difficulty: Medium-High. Building a good desktop app or local-first web app requires different architecture patterns than standard SaaS. Tauri is the recommended framework (Rust backend, web frontend, small binary size, no Electron bloat), but it has a learning curve.

Revenue potential:

The unit economics are exceptional: Because the processing happens on the user's machine, your hosting costs are near zero. A traditional SaaS at $29/month might spend $5-10 per user on infrastructure. A local-first SaaS at $29/month spends $0.10 per user on a license server and update distribution. Your margins are 95%+ instead of 60-70%.

Real example: 4DA (the product this playbook is part of) is a Tauri desktop app that runs local AI inference, local database, and local file processing. Infrastructure cost per user: effectively zero. The Signal tier at $12/month is almost entirely margin.

Start This Week:

Pick one cloud-dependent tool that handles sensitive data and build a local-first alternative. Not the whole thing — an MVP that does the one most important feature locally.

Ideas:

• Local-first meeting note transcription (Whisper + summarization model)
• Private code snippet manager with AI search (local embeddings)
• On-device resume/document analyzer for HR teams
• Local financial document processor for accountants

# Scaffold a Tauri app in 5 minutes
pnpm create tauri-app my-private-tool --template react-ts
cd my-private-tool
pnpm install
pnpm run tauri dev

Opportunity 5: "Vibe Coding" Education

Teach non-developers to build with AI — they're desperate for quality guidance.

What it is: Courses, tutorials, coaching, and communities that teach product managers, designers, marketers, and entrepreneurs how to build real applications using AI coding tools.

Market size: Conservative estimate: 10-20 million non-developers attempted to build software with AI in 2025. Most of them hit a wall. They need help that's calibrated to their skill level — not "learn to code from scratch" and not "here's an advanced systems design course."

Competition: Growing fast, but quality is shockingly low. Most "vibe coding" education is either:

• Too shallow: "Just tell ChatGPT to build it!" (This breaks the moment anything real is needed.)
• Too deep: Standard programming courses relabeled as "AI-powered." (Their audience doesn't want to learn programming fundamentals — they want to build a specific thing.)
• Too narrow: Tutorial for one specific tool that becomes outdated in 3 months.

The gap is for structured, practical content that treats AI as a genuine tool (not magic) and teaches enough programming context to make informed decisions without requiring a CS degree.

Entry difficulty: Low if you can teach. Medium if you can't (teaching is a skill). The technical barrier is near zero — you already know this stuff. The challenge is explaining it to people who don't think like developers.

Revenue potential:

Start This Week:

1. Record a 10-minute screen recording: "Build a working app from scratch using Claude Code — no coding experience required." Walk through a real build. Don't fake it.
2. Post it on YouTube and Twitter/X.
3. At the end, link to a waitlist for a full course.
4. If 50+ people join the waitlist in a week, you have a viable product. Build the course.

Common Mistake: Underpricing education. Developers instinctively want to give away knowledge for free. But a non-developer who builds a working internal tool using your $149 course just saved their company $20,000 in development costs. Your course is a bargain. Price for the value delivered, not the hours spent creating it.

Opportunity 6: Fine-Tuned Model Services

Domain-specific AI models that general-purpose models can't match.

What it is: Creating custom fine-tuned models for specific industries or use cases, then selling them as a service (inference API) or as deployable packages.

Market size: Niche by definition, but the niches are individually lucrative. A legal firm that needs a model fine-tuned on contract language, a healthcare company that needs a model trained on clinical notes, a financial firm that needs a model calibrated for regulatory filings — each will pay $5,000-50,000 for something that works.

Competition: Low in specific niches, moderate in general. The big AI companies don't fine-tune for individual clients at this scale. The opportunity is in the long tail — specialized models for specific use cases that aren't worth OpenAI's attention.

Entry difficulty: Medium-High. You need to understand fine-tuning workflows (LoRA, QLoRA), data preparation, evaluation metrics, and model deployment. But the tools have matured significantly — Unsloth, Axolotl, and Hugging Face TRL make fine-tuning accessible on consumer GPUs.

Revenue potential:

Start This Week:

1. Pick a domain you have data access to (or can legally obtain training data for).
2. Fine-tune a Llama 3.3 8B model using QLoRA on a specific task:

# Install Unsloth (fastest fine-tuning library as of 2026)
pip install unsloth

# Example: Fine-tune on customer support data
# You need ~500-2000 examples of (input, ideal_output) pairs
# Format as JSONL:
# {"instruction": "Categorize this ticket", "input": "My login isn't working", "output": "category: authentication, priority: high, sentiment: frustrated"}

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/llama-3.3-8b-bnb-4bit",
    max_seq_length=2048,
    load_in_4bit=True,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_alpha=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",
)

# Train on your domain-specific data
# ... (see Unsloth documentation for full training loop)

# Export for Ollama
model.save_pretrained_gguf("my-domain-model", tokenizer, quantization_method="q4_k_m")

3. Benchmark the fine-tuned model against the base model on 50 domain-specific test cases. Document the improvement.
4. Write up the case study: "How a fine-tuned 8B model outperformed GPT-4o on [domain] task classification."

Opportunity 7: AI-Powered Content at Scale

Niche newsletters, intelligence reports, and curated digests.

What it is: Using local LLMs to ingest, classify, and summarize domain-specific content, then adding your expertise to create premium intelligence products.

Market size: Every industry has professionals drowning in information. Developers, lawyers, doctors, researchers, investors, product managers — they all need curated, relevant, timely intelligence. Generic newsletters are saturated. Niche ones are not.

Competition: Moderate for broad tech newsletters. Low for deep niches. There's no good "Rust + AI" weekly intelligence report. There's no "Local AI Deployment" monthly brief. There's no "Privacy Engineering" digest for CTOs. These niches are waiting.

Entry difficulty: Low. The hardest part is consistency, not technology. A local LLM handles 80% of the curation work. You handle the 20% that requires taste.

Revenue potential:

The production pipeline (how to produce a weekly newsletter in 3-4 hours):

#!/usr/bin/env python3
"""
newsletter_pipeline.py
Automated intelligence gathering for a niche newsletter.
Uses local LLM for classification and summarization.
"""

import requests
import json
import feedparser
from datetime import datetime, timedelta

OLLAMA_URL = "http://127.0.0.1:11434/api/generate"
MODEL = "qwen2.5:14b"  # Good balance of speed and quality

# Your curated source list (10 high-signal sources > 100 noisy ones)
SOURCES = [
    {"type": "rss", "url": "https://hnrss.org/newest?q=local+AI+OR+ollama+OR+llama.cpp", "name": "HN Local AI"},
    {"type": "rss", "url": "https://www.reddit.com/r/LocalLLaMA/.rss", "name": "r/LocalLLaMA"},
    # Add your niche-specific sources here
]

def classify_relevance(title: str, summary: str, niche: str) -> dict:
    """Use local LLM to classify if an item is relevant to your niche."""
    prompt = f"""You are a content curator for a newsletter about {niche}.

Rate this item's relevance (1-10) and explain in one sentence why.
If relevance >= 7, write a 2-sentence summary suitable for a newsletter.

Title: {title}
Content: {summary[:500]}

Respond in JSON: {{"relevance": N, "reason": "...", "summary": "..." or null}}"""

    response = requests.post(OLLAMA_URL, json={
        "model": MODEL,
        "prompt": prompt,
        "stream": False,
        "format": "json",
        "options": {"temperature": 0.3}
    }, timeout=60)

    try:
        return json.loads(response.json()["response"])
    except (json.JSONDecodeError, KeyError):
        return {"relevance": 0, "reason": "parse error", "summary": None}

def gather_and_classify(niche: str, min_relevance: int = 7):
    """Gather items from all sources and classify them."""
    items = []

    for source in SOURCES:
        if source["type"] == "rss":
            feed = feedparser.parse(source["url"])
            for entry in feed.entries[:20]:  # Last 20 items per source
                classification = classify_relevance(
                    entry.get("title", ""),
                    entry.get("summary", ""),
                    niche
                )
                if classification.get("relevance", 0) >= min_relevance:
                    items.append({
                        "title": entry.get("title"),
                        "link": entry.get("link"),
                        "source": source["name"],
                        "relevance": classification["relevance"],
                        "summary": classification["summary"],
                        "classified_at": datetime.now().isoformat()
                    })

    # Sort by relevance, take top 10
    items.sort(key=lambda x: x["relevance"], reverse=True)
    return items[:10]

if __name__ == "__main__":
    # Example: "Local AI Deployment" niche
    results = gather_and_classify("local AI deployment and privacy-first infrastructure")

    print(f"\n{'='*60}")
    print(f"Top {len(results)} items for this week's newsletter:")
    print(f"{'='*60}\n")

    for i, item in enumerate(results, 1):
        print(f"{i}. [{item['relevance']}/10] {item['title']}")
        print(f"   Source: {item['source']}")
        print(f"   {item['summary']}")
        print(f"   {item['link']}\n")

    # Save to file — you'll edit this into your newsletter
    with open("newsletter_draft.json", "w") as f:
        json.dump(results, f, indent=2)

    print(f"Draft saved to newsletter_draft.json")
    print(f"Your job: review these, add your analysis, write the intro.")
    print(f"Estimated time to finish: 2-3 hours.")

Start This Week:

1. Pick your niche. It should be specific enough that you can name 10 high-signal sources and broad enough that there's a new story every week.
2. Run the pipeline above (or something like it) for one week.
3. Write a "Week 1" newsletter. Send it to 10 people you know in the niche. Ask: "Would you pay $10/month for this?"
4. If 3+ say yes, launch on Buttondown or Substack. Charge from day one.

Real Talk: The hardest part of a newsletter isn't writing — it's continuing. Most newsletters die between issue 4 and issue 12. The pipeline above exists to make production sustainable. If gathering content takes 30 minutes instead of 3 hours, you're much more likely to ship consistently. Use the LLM for the grunt work. Save your energy for the insight.

Your Turn

1. Rank the opportunities. Order the seven opportunities above from most to least attractive for YOUR situation. Consider your skills, hardware, available time, and risk tolerance.

2. Pick one. Not three, not "all of them eventually." One. The one you'll start this week.

3. Complete the "Start This Week" action plan. Every opportunity above has a concrete first-week plan. Do it. Publish something by Sunday.

4. Set a 30-day checkpoint. Write down what "success" looks like in 30 days for your chosen opportunity. Be specific: revenue target, user count, content published, clients contacted.

Lesson 3: Timing Markets — When to Enter, When to Exit

"Picking the right opportunity at the wrong time is the same as picking the wrong opportunity."

The Developer Technology Adoption Curve

Every technology goes through a predictable cycle. Understanding where a technology sits on this curve tells you what kind of money can be made and how much competition you'll face.

  Innovation        Early           Growth          Maturity        Decline
  Trigger          Adoption         Phase           Phase           Phase
     |               |               |               |               |
  "Interesting"  "Some devs     "Everyone's      "Enterprise     "Legacy,
   paper/demo     use it for      using it or      standard.       being
   at a conf"     real work"      evaluating it"   Boring."        replaced"

  Revenue:        Revenue:        Revenue:         Revenue:        Revenue:
  $0 (too early)  HIGH margins    Volume play,     Commoditized,   Maintenance
                  Low competition  margins drop     low margins     only
                  First-mover      Competition      Big players     Niche players
                  advantage        increases        dominate        survive

Where each 2026 opportunity sits:

The "Too Early / Just Right / Too Late" Framework

For any opportunity, ask three questions:

Am I too early?

• Is there a paying customer who wants this TODAY? (Not "would want it in theory.")
• Can I find 10 people who would pay for this if I built it this month?
• Is the underlying technology stable enough to build on without rewriting every quarter?

If any answer is "no," you're too early. Wait, but watch closely.

Am I just right?

• Demand exists and is growing (not just stable)
• Supply is insufficient (few competitors, or competitors are poor quality)
• The technology is stable enough to build on
• Early movers haven't yet locked up distribution
• You can ship an MVP in 2-4 weeks

If all true, move fast. This is the window.

Am I too late?

• Well-funded startups have entered the space
• Platform providers are building native solutions
• Pricing is racing to the bottom
• "Best practices" are well-established (no room for differentiation)
• You'd be building a commodity

If any is true, look for a niche within the opportunity that isn't yet commoditized, or move on entirely.

Reading the Signals: How to Know When a Market Is Opening

You don't need to predict the future. You need to read the present accurately. Here's what to watch.

Signal 1: Hacker News Front Page Frequency

When a technology appears on the HN front page weekly instead of monthly, attention is shifting. When HN comments shift from "what is this?" to "how do I use this?", money follows within 3-6 months.

# Quick and dirty HN signal check using the Algolia API
curl -s "https://hn.algolia.com/api/v1/search?query=MCP+server&tags=story&hitsPerPage=5" \
  | python3 -c "
import sys, json
data = json.load(sys.stdin)
for hit in data.get('hits', []):
    print(f\"{hit.get('points', 0):4d} pts | {hit.get('created_at', '')[:10]} | {hit.get('title', '')}\")
"

Signal 2: GitHub Stars Velocity

Absolute star count doesn't matter. Velocity does. A repo going from 0 to 5,000 stars in 3 months is a stronger signal than a repo sitting at 50,000 stars for 2 years.

Signal 3: Job Posting Growth

When companies start hiring for a technology, they're committing budget. Job postings are a lagging indicator of adoption but a leading indicator of enterprise spend.

Signal 4: Conference Talk Acceptance Rates

When conference CFPs start accepting talks about a technology, it's crossing from niche to mainstream. When conferences create dedicated tracks for it, enterprise adoption is imminent.

Reading the Signals: How to Know When a Market Is Closing

This is harder. Nobody wants to admit they're late. But these signals are reliable.

Signal 1: Enterprise Adoption

When Gartner writes a Magic Quadrant for a technology, the early-mover window is over. Big consultancies (Deloitte, Accenture, McKinsey) writing reports about it means commoditization is 12-18 months away.

Signal 2: VC Funding Rounds

When a competitor in your space raises $10M+, your window to compete on similar terms closes. They'll outspend you on marketing, hiring, and features. Your play shifts to niche positioning or exit.

Signal 3: Platform Integration

When the platform builds it natively, your third-party solution's days are numbered. Examples:

• When GitHub added Copilot natively, standalone code completion tools died.
• When VS Code added built-in terminal management, terminal plugins lost relevance.
• When Vercel adds native AI features, some AI-wrapper products built on Vercel become redundant.

Watch for platform announcements. When the platform you build on announces they're building your feature, you have 6-12 months to either differentiate or pivot.

Real Historical Examples

The pattern: Developer tool windows last 12-24 months on average. AI-adjacent windows are shorter (6-12 months) because the pace of change is faster. The MCP window is probably 12-18 months from today. After that, the marketplace infrastructure will exist, early winners will have distribution, and entering will require significantly more effort.

The Decision Framework

When evaluating any opportunity, use this:

1. Where is this technology on the adoption curve?
   [ ] Innovation → Too early (unless you enjoy risk)
   [ ] Early Adoption → Best window for indie developers
   [ ] Growth → Still viable but need to differentiate
   [ ] Maturity → Commodity. Compete on price or leave.
   [ ] Decline → Only if you're already in and profitable

2. What are the leading signals saying?
   HN frequency:     [ ] Rising  [ ] Stable  [ ] Declining
   GitHub velocity:   [ ] Rising  [ ] Stable  [ ] Declining
   Job postings:      [ ] Rising  [ ] Stable  [ ] Declining
   VC funding:        [ ] None    [ ] Seed    [ ] Series A+  [ ] Late stage

3. What's my honest entry difficulty?
   [ ] Can ship MVP this month
   [ ] Can ship MVP this quarter
   [ ] Would take 6+ months (probably too slow)

4. Decision:
   [ ] Enter now (signals strong, timing right, can ship fast)
   [ ] Watch and prepare (signals mixed, build skills/prototype)
   [ ] Skip (too early, too late, or too hard for current situation)

Common Mistake: Analysis paralysis — spending so long evaluating the timing that the window closes while you're still evaluating. The framework above should take 15 minutes per opportunity. If you can't decide in 15 minutes, you don't have enough information. Go build a prototype and get real market feedback instead.

Your Turn

1. Evaluate your chosen opportunity from Lesson 2 using the decision framework above. Be honest about the timing.
2. Check the HN signal for your chosen area. Run the API query above (or manually search). What's the frequency and sentiment?
3. Identify one signal source you'll monitor weekly for your chosen market. Set a calendar reminder: "Check [signal] every Monday morning."
4. Write your timing thesis. In 3 sentences: Why is now the right time for your opportunity? What would make you wrong? What would make you double down?

Lesson 4: Building Your Intelligence System

"The developer who sees the signal first gets paid first."

Why Most Developers Miss Opportunities

Information overload is not the problem. Information disorganization is the problem.

The average developer in 2026 is exposed to:

• 50-100 Hacker News stories per day
• 200+ tweets from people they follow
• 10-30 newsletter emails per week
• 5-15 Slack/Discord conversations happening simultaneously
• Dozens of GitHub notifications
• Miscellaneous blog posts, YouTube videos, podcast mentions

Total input: thousands of signals per week. Number that actually matter for income decisions: maybe 3-5.

You don't need more information. You need a filter. An intelligence system that reduces thousands of inputs to a handful of actionable signals.

The "10 High-Signal Sources" Approach

Instead of monitoring 100 noisy channels, pick 10 high-signal sources and monitor them well.

High-signal source criteria:

1. Produces content relevant to your income niche
2. Has a track record of surfacing things early (not just aggregating old news)
3. Can be consumed in under 5 minutes per session
4. Can be automated (RSS feed, API, or structured format)

Example: A "Local AI + Privacy" intelligence stack:

# intelligence-sources.yml
# Your 10 high-signal sources — review weekly

sources:
  # Tier 1: Primary signals (check daily)
  - name: "HN — Local AI filter"
    url: "https://hnrss.org/newest?q=local+AI+OR+ollama+OR+llama.cpp+OR+private+AI&points=30"
    frequency: daily
    signal: "What developers are building and discussing"

  - name: "r/LocalLLaMA"
    url: "https://www.reddit.com/r/LocalLLaMA/top/.rss?t=week"
    frequency: daily
    signal: "Model releases, benchmarks, production use cases"

  - name: "r/selfhosted"
    url: "https://www.reddit.com/r/selfhosted/top/.rss?t=week"
    frequency: daily
    signal: "What people want to run locally (demand signals)"

  # Tier 2: Ecosystem signals (check twice/week)
  - name: "GitHub Trending — Rust"
    url: "https://github.com/trending/rust?since=weekly"
    frequency: twice_weekly
    signal: "New tools and libraries gaining traction"

  - name: "GitHub Trending — TypeScript"
    url: "https://github.com/trending/typescript?since=weekly"
    frequency: twice_weekly
    signal: "Frontend and tooling trends"

  - name: "Ollama Blog + Releases"
    url: "https://ollama.com/blog"
    frequency: twice_weekly
    signal: "Model and infrastructure updates"

  # Tier 3: Market signals (check weekly)
  - name: "Simon Willison's Blog"
    url: "https://simonwillison.net/atom/everything/"
    frequency: weekly
    signal: "Expert analysis of AI tools and trends"

  - name: "Changelog News"
    url: "https://changelog.com/news/feed"
    frequency: weekly
    signal: "Curated developer ecosystem news"

  - name: "TLDR AI Newsletter"
    url: "https://tldr.tech/ai"
    frequency: weekly
    signal: "AI industry overview"

  # Tier 4: Deep signals (check monthly)
  - name: "EU AI Act Updates"
    url: "https://artificialintelligenceact.eu/"
    frequency: monthly
    signal: "Regulatory changes affecting privacy-first demand"

Setting Up Your Intelligence Stack

Layer 1: Automated Collection (4DA)

If you're using 4DA, this is already handled. 4DA ingests from configurable sources, classifies by relevance to your Developer DNA, and surfaces the highest-signal items in your daily briefing. Configure an LLM provider in settings for AI-powered classification — Ollama with a local model works perfectly for this.

Layer 2: RSS for Everything Else

For sources 4DA doesn't cover, use RSS. Every serious intelligence operation runs on RSS because it's structured, automated, and doesn't depend on an algorithm deciding what you see.

# Install a command-line RSS reader for quick scanning
# Option 1: newsboat (Linux/Mac)
# sudo apt install newsboat   # Linux
# brew install newsboat        # macOS

# Option 2: Use a web-based reader
# Miniflux (self-hosted, privacy-respecting) — https://miniflux.app
# Feedbin ($5/mo, excellent) — https://feedbin.com
# Inoreader (free tier) — https://www.inoreader.com

# newsboat configuration example
# Save as ~/.newsboat/urls

# Primary signals
https://hnrss.org/newest?q=MCP+server&points=20 "~HN: MCP Servers"
https://hnrss.org/newest?q=local+AI+OR+ollama&points=30 "~HN: Local AI"
https://www.reddit.com/r/LocalLLaMA/top/.rss?t=week "~Reddit: LocalLLaMA"

# Ecosystem signals
https://simonwillison.net/atom/everything/ "~Simon Willison"
https://changelog.com/news/feed "~Changelog"

# Your niche (customize these)
# [Add your domain-specific RSS feeds here]

Layer 3: Twitter/X Lists (Curated)

Don't follow people on your main feed. Create a private list of 20-30 thought leaders in your niche. Check the list, not your feed.

How to build an effective list:

1. Start with 5 people whose content you consistently find valuable
2. Look at who they retweet and engage with
3. Add those people
4. Prune anyone who posts more than 50% opinion/hot takes (you want signal, not takes)
5. Target: 20-30 accounts that surface information early

Layer 4: GitHub Trending (Weekly)

Check GitHub Trending weekly, not daily. Daily is noise. Weekly surfaces projects with sustained momentum.

# Script to check GitHub trending repos in your languages
# Save as check_trending.sh

#!/bin/bash
echo "=== GitHub Trending This Week ==="
echo ""
echo "--- Rust ---"
curl -s "https://api.github.com/search/repositories?q=created:>$(date -d '7 days ago' +%Y-%m-%d)+language:rust&sort=stars&order=desc&per_page=5" \
  | python3 -c "
import sys, json
data = json.load(sys.stdin)
for repo in data.get('items', []):
    print(f\"  ★ {repo['stargazers_count']:>5} | {repo['full_name']}: {repo.get('description', 'No description')[:80]}\")
"

echo ""
echo "--- TypeScript ---"
curl -s "https://api.github.com/search/repositories?q=created:>$(date -d '7 days ago' +%Y-%m-%d)+language:typescript&sort=stars&order=desc&per_page=5" \
  | python3 -c "
import sys, json
data = json.load(sys.stdin)
for repo in data.get('items', []):
    print(f\"  ★ {repo['stargazers_count']:>5} | {repo['full_name']}: {repo.get('description', 'No description')[:80]}\")
"

The 15-Minute Morning Scan

This is the routine. Every morning. 15 minutes. Not 60. Not "when I have time." Fifteen minutes, with a timer.

Minute 0-3:   Check 4DA dashboard (or RSS reader) for overnight signals
Minute 3-6:   Scan Twitter/X list (NOT main feed) — skim headlines only
Minute 6-9:   Check GitHub Trending (weekly) or HN front page (daily)
Minute 9-12:  If any signal is interesting, bookmark it (don't read it now)
Minute 12-15: Write down ONE observation in your intelligence log

That's it. Close everything. Start your real work.

The intelligence log:

Keep a simple file. Date and one observation. That's all.

# Intelligence Log — 2026

## February

### 2026-02-17
- MCP server for Playwright testing appeared on HN front page (400+ pts).
  Testing automation via MCP is heating up. My agent templates could target this.

### 2026-02-14
- r/LocalLLaMA post about running Qwen 2.5 72B on M4 Max (128GB) at 25 tok/s.
  Apple Silicon is becoming a serious local AI platform. Mac-focused consulting?

### 2026-02-12
- EU AI Act transparency obligations now enforced. LinkedIn full of CTOs posting
  about compliance scrambles. Local AI consulting demand spike incoming.

After 30 days, review the log. Patterns will emerge that you can't see in real-time.

Turning Intelligence into Action: The Signal → Opportunity → Decision Pipeline

Most developers collect intelligence and then do nothing with it. They read HN, nod along, and go back to their job. That's entertainment, not intelligence.

Here's how to turn signal into money:

SIGNAL (raw information)
  ↓
  Filter: Does this relate to any of the 7 opportunities from Lesson 2?
  If no → discard
  If yes ↓

OPPORTUNITY (filtered signal + context)
  ↓
  Evaluate: Using the timing framework from Lesson 3
  - Too early? → bookmark, check back in 30 days
  - Just right? ↓
  - Too late? → discard

DECISION (actionable commitment)
  ↓
  Choose one of:
  a) ACT NOW — start building this week
  b) PREPARE — build skills/prototype, act next month
  c) WATCH — add to intelligence log, re-evaluate in 90 days
  d) SKIP — not for me, no action needed

The key is making the decision explicitly. "That's interesting" is not a decision. "I will build an MCP server for Playwright testing this weekend" is a decision. "I'll watch MCP testing tools for 30 days and decide March 15 whether to enter" is also a decision. Even "I'm skipping this because it doesn't match my skills" is a decision.

Undecided items clog your mental pipeline. Decide, even if the decision is to wait.

Your Turn

1. Build your source list. Using the template above, list your 10 high-signal sources. Be specific — exact URLs, not "follow tech Twitter."
2. Set up your infrastructure. Install an RSS reader (or configure 4DA) with your sources. This should take 30 minutes, not a weekend.
3. Start your intelligence log. Create the file. Write today's first entry. Set a daily reminder for your 15-minute morning scan.
4. Process one signal through the pipeline. Take something you saw this week in tech news. Run it through the Signal → Opportunity → Decision pipeline. Write down the explicit decision.
5. Schedule your first 30-day review. Put it on your calendar: review your intelligence log in 30 days, identify patterns.

Lesson 5: Future-Proofing Your Income

"The best time to learn a skill is 12 months before the market pays for it."

The 12-Month Skill Lead

Every skill you're getting paid for today, you learned 1-3 years ago. That's the lag. The skills that will pay you in 2027 are the ones you start learning now.

This doesn't mean chasing every trend. It means maintaining a small portfolio of "bets" — skills you invest learning time in before they become obviously marketable.

The developers who were learning Rust in 2020 are the ones charging $250-400/hour for Rust consulting in 2026. The developers who learned Kubernetes in 2017 were the ones commanding premium rates in 2019-2022. The pattern repeats.

The question is: what should you be learning NOW that the market will pay for in 2027-2028?

What Will Likely Matter in 2027 (Educated Predictions)

These aren't guesses — they're extrapolations from current trajectories with real evidence behind them.

Prediction 1: On-Device AI (Phones and Tablets as Compute Nodes)

Apple Intelligence shipped in 2024-2025 with limited capabilities. Qualcomm's Snapdragon X Elite put 45 TOPS of AI compute in laptops. Samsung and Google are adding on-device inference to phones.

By 2027, expect:

• 3B-7B models running on flagship phones at usable speeds
• On-device AI as a standard OS feature (not an app)
• New app categories that process sensitive data without ever contacting a server

Income implication: Apps that leverage on-device inference for tasks that can't send data to the cloud (health data, financial data, personal photos). The development skills: mobile ML deployment, model quantization, on-device optimization.

Learning investment now: Pick up Apple's Core ML or Google's ML Kit. Spend 20 hours understanding model quantization with llama.cpp for mobile targets. This expertise will be scarce and valuable in 18 months.

Prediction 2: Agent-to-Agent Commerce

MCP lets humans connect AI agents to tools. The next step is agents connecting to OTHER agents. An agent that needs legal analysis calls a legal analysis agent. An agent building a website calls a design agent. Agents as microservices.

By 2027, expect:

• Standardized protocols for agent-to-agent discovery and invocation
• Billing mechanisms for agent-to-agent transactions
• A marketplace where your agent can earn money by serving other agents

Income implication: If you build an agent that provides a valuable service, other agents can be your customers — not just humans. This is passive income in the most literal sense.

Learning investment now: Understand MCP deeply (not just "how to build a server" but the protocol specification). Build agents that expose clean, composable interfaces. Think API design, but for AI consumers.

Prediction 3: Decentralized AI Marketplaces

Peer-to-peer inference networks where developers sell spare GPU compute are moving from concept to early implementation. Projects like Petals, Exo, and various blockchain-based inference networks are building infrastructure for this.

By 2027, expect:

• At least one mainstream network for selling GPU compute
• Tooling for easy participation (not just for crypto enthusiasts)
• Revenue potential: $50-500/month from idle GPU time

Income implication: Your GPU could be earning money while you sleep, without you running any specific service. You'd just contribute compute to a network and get paid.

Learning investment now: Run a Petals or Exo node. Understand the economics. The infrastructure is immature but the fundamentals are solid.

Prediction 4: Multimodal Applications (Voice + Vision + Text)

Local multimodal models (LLaVA, Qwen-VL, Fuyu) are improving rapidly. Voice models (Whisper, Bark, XTTS) are already production-quality locally. The convergence of text + image + voice + video processing on local hardware opens new application categories.

By 2027, expect:

• Local models that process video, images, and voice with the same ease we currently process text
• Apps that analyze visual content without sending it to the cloud
• Voice-first interfaces powered by local models

Income implication: Applications that process multimodal content locally — video analysis tools, voice-controlled development environments, visual inspection systems for manufacturing.

Learning investment now: Experiment with LLaVA or Qwen-VL through Ollama. Build one prototype that processes images locally. Understand the latency and quality trade-offs.

# Try a multimodal model locally right now
ollama pull llava:13b

# Analyze an image (you need to base64 encode it)
# This will process entirely on your machine
curl http://localhost:11434/api/generate -d '{
  "model": "llava:13b",
  "prompt": "Describe what you see in this image in detail. Focus on any technical elements.",
  "images": ["<base64-encoded-image>"],
  "stream": false
}'

Prediction 5: AI Regulation Expanding Globally

The EU AI Act is the first, but not the last. Brazil, Canada, Japan, South Korea, and several US states are developing AI regulation. India is considering disclosure requirements. The global regulatory surface area is expanding.

By 2027, expect:

• At least 3-4 major jurisdictions with AI-specific regulation
• Compliance consulting becoming a defined professional service category
• "AI audit" as a standard procurement requirement for enterprise software

Income implication: Compliance expertise becomes increasingly valuable. If you can help a company demonstrate that their AI system meets regulatory requirements across multiple jurisdictions, you're offering a service that's worth $200-500/hour.

Learning investment now: Read the EU AI Act (not summaries — the actual text). Understand the risk classification system. Follow NIST AI Risk Management Framework. This knowledge compounds.

Skills That Transfer Regardless of Trend Shifts

Trends come and go. These skills remain valuable across every cycle:

1. Systems Thinking Understanding how components interact in complex systems. Whether it's a microservice architecture, a machine learning pipeline, or a business process — the ability to reason about emergent behavior from component interactions is permanently valuable.

2. Privacy and Security Expertise Every trend makes data more valuable. Every regulation makes data handling more complex. Security and privacy expertise is a permanent moat. The developer who understands both "how to build it" and "how to build it safely" commands 1.5-2x the rate.

3. API Design Every era creates new APIs. REST, GraphQL, WebSockets, MCP, agent protocols — the specifics change but the principles of designing clean, composable, well-documented interfaces are constant. Good API design is rare and valuable.

4. Developer Experience (DX) Design The ability to make tools that other developers actually enjoy using. This is a combination of technical skill, empathy, and taste that very few people have. If you can build tools with great DX, you can build them in any technology and they'll find users.

5. Technical Writing The ability to explain complex technical concepts clearly. This is valuable in every context: documentation, blog posts, courses, consulting deliverables, open-source README files, product marketing. Good technical writing is permanently scarce and permanently in demand.

The "Skill Insurance" Strategy

Allocate your learning time across three horizons:

|  Horizon  |  Time Allocation  |  Example (2026)                    |
|-----------|-------------------|------------------------------------|
| NOW       | 60% of learning   | Deepen your current stack          |
|           |                   | (the skills you earn from today)   |
|           |                   |                                    |
| 12 MONTHS | 30% of learning   | On-device AI, agent protocols,     |
|           |                   | multimodal processing              |
|           |                   | (skills that will pay in 2027)     |
|           |                   |                                    |
| 36 MONTHS | 10% of learning   | Decentralized AI, agent commerce,  |
|           |                   | cross-jurisdiction compliance      |
|           |                   | (awareness level, not expertise)   |

The 60/30/10 split is deliberate:

• 60% on "NOW" skills keeps you earning and ensures your current income streams stay healthy
• 30% on "12 MONTHS" skills builds the foundation for your next revenue stream before you need it
• 10% on "36 MONTHS" skills keeps you aware of what's coming without over-investing in things that might not materialize

Common Mistake: Spending 80% of learning time on "36 MONTHS" horizon stuff because it's exciting, while your current income streams rot because you're not maintaining the underlying skills. Future-proofing doesn't mean abandoning the present. It means maintaining the present while strategically scouting the future.

How to Actually Learn (Efficiently)

Developer learning has a productivity problem. Most "learning" is actually:

• Reading tutorials without building anything (retention: ~10%)
• Watching YouTube at 2x speed (retention: ~5%)
• Buying courses and finishing 20% (retention: ~15%)
• Reading documentation when stuck, solving the immediate problem, and immediately forgetting (retention: ~20%)

The only method with consistently high retention is building something real with the new skill and publishing it.

Read about it:           10% retention
Watch a tutorial:        15% retention
Follow along:            30% retention
Build something real:    60% retention
Build and publish:       80% retention
Build, publish, teach:   95% retention

For every "12 MONTHS" skill you invest in, the minimum output should be:

1. One working prototype (not a toy — something that handles a real use case)
2. One published artifact (blog post, open-source repo, or product)
3. One conversation with someone who would pay for this skill

That's how you convert learning time into future income.

Your Turn

1. Write your 60/30/10 split. What are your NOW skills (60%), 12 MONTHS skills (30%), and 36 MONTHS skills (10%)? Be specific — name the technologies, not just the categories.
2. Pick one 12 MONTHS skill and spend 2 hours this week on it. Not reading about it — building something with it, even if it's trivial.
3. Audit your current learning habits. How much of your learning time in the last month resulted in a published artifact? If the answer is "none," that's the thing to fix.
4. Set a calendar reminder for 6 months from now: "Review skill predictions. Were the 12-month bets accurate? Adjust allocation."

Scaling From $500/Month to $10K/Month

Most developer income streams stall between $500/month and $2,000/month. You've proven the concept, customers exist, revenue is real — but growth plateaus. This section is the practical playbook for breaking through that plateau.

Why streams stall at $500-2,000/month:

1. You hit your personal throughput ceiling. There are only so many support tickets, consulting hours, or content pieces one person can produce.
2. You're doing everything yourself. Marketing, development, support, accounting, content — context-switching is killing your effective output.
3. Your pricing is too low. You set launch prices to attract early customers and never raised them.
4. You're not saying no. Feature requests, custom work, "quick calls" — small distractions compound into major time drains.

The $500 to $2K Phase: Fix Your Pricing

If you're making $500/month, your first move is almost always a price increase, not more customers. Most developers underprice by 30-50%.

Current: 100 customers x $5/month = $500/month
Option A: Get 100 MORE customers (double the support, marketing, infrastructure) = $1,000/month
Option B: Raise price to $9/month, lose 20% of customers = 80 x $9 = $720/month

Option B gives you 44% more revenue with FEWER customers and LESS support load.
At $15/month with the same 20% churn: 80 x $15 = $1,200/month — 140% increase.

The evidence: Patrick McKenzie's analysis of thousands of SaaS products shows that indie developers almost universally underprice. The customers you lose to a price increase are typically the ones who generate the most support tickets and the least goodwill. Your best customers barely notice a 50% price increase because the value you provide far exceeds the cost.

How to raise prices without losing your nerve:

1. Grandfather existing customers at their current rate (optional but reduces friction)
2. Announce 30 days in advance via email: "Starting [date], new pricing is [X]. Your current rate is locked for [6 months / forever]."
3. Add one small improvement alongside the increase — a new feature, faster performance, better docs. The improvement doesn't need to justify the price increase, but it gives customers something positive to associate with the change.
4. Track churn for 60 days. If churn stays under 10%, the price increase was correct. If churn exceeds 20%, you may have jumped too far — consider an intermediate tier.

The $2K to $5K Phase: Automate or Delegate

At $2K/month, you can afford to start removing yourself from low-value tasks. The math works:

Your effective hourly rate at $2K/month, 20 hrs/week = $25/hr
A virtual assistant costs $10-20/hr
A contract developer costs $30-60/hr

Tasks to delegate FIRST (highest leverage):
1. Customer support (VA, $10-15/hr) — frees 3-5 hrs/week
2. Content formatting/scheduling (VA, $10-15/hr) — frees 2-3 hrs/week
3. Bookkeeping (specialized VA, $15-25/hr) — frees 1-2 hrs/week

Total cost: ~$400-600/month
Time freed: 6-10 hrs/week
Those 6-10 hours go to product development, marketing, or a second stream.

Hiring your first contractor:

• Start with a single, defined task. Not "help me with my business." More like "respond to support tickets using this playbook document, escalate anything that requires code changes."
• Where to find them: Upwork (filter for 90%+ job success, 100+ hours), OnlineJobs.ph (for VAs), or personal referrals from other indie developers.
• Pay fairly. The contractor who costs $8/hr and needs constant supervision is more expensive than the one who costs $15/hr and works independently.
• Create a runbook first. Document every repeatable task before handing it off. If you can't write the process down, you can't delegate it.
• Trial period: 2 weeks, paid, with a specific deliverable. End the trial if quality isn't there. Don't invest months "training" someone who isn't a fit.

The $5K to $10K Phase: Systems, Not Effort

At $5K/month, you're past the "side project" phase. This is a real business. The jump to $10K requires systems thinking, not just more effort.

Three levers at this stage:

1. Expand your product line. Your existing customers are your warmest audience. What adjacent product can you sell them?

   • SaaS customers want templates, guides, or consulting
   • Template buyers want a SaaS that automates what the template does manually
   • Consulting clients want productized services (fixed scope, fixed price)

2. Build distribution channels that compound.

   • SEO: Every blog post is a permanent lead source. Invest in 2-4 high-quality posts per month targeting long-tail keywords in your niche.
   • Email list: This is your most valuable asset. Nurture it. One focused email per week to your list outperforms daily social media posting.
   • Partnerships: Find complementary (not competing) products and cross-promote. A design system tool partnering with a component library is natural.

3. Raise prices again. If you raised prices at $500/month and haven't since, it's time. Your product is better now. Your reputation is stronger. Your support infrastructure is more reliable. The value has increased — the price should reflect that.

Automating fulfillment:

At $5K+/month, manual fulfillment becomes a bottleneck. Automate these first:

The mindset shift at $10K/month:

Below $10K, you're optimizing for revenue growth. At $10K, you start optimizing for time efficiency. The question changes from "how do I make more money?" to "how do I make the same money in fewer hours?" — because that freed time is what you invest in the next phase of growth.

When to Kill a Stream: The Decision Framework

Module S2 covers the four kill rules in depth (The $100 Rule, The ROI Rule, The Energy Rule, The Opportunity Cost Rule). Here's the complementary framework for the Evolving Edge context — where market timing determines whether a struggling stream is a patience problem or a market problem.

The Market Timing Kill Criteria:

Not every underperforming stream deserves more effort. Some are genuinely early (patience pays). Others are late (the window closed while you were building). Distinguishing between the two is the difference between persistence and stubbornness.

STREAM HEALTH ASSESSMENT

Stream name: _______________
Age: _____ months
Monthly revenue: $_____
Monthly hours invested: _____
Revenue trend (last 3 months): [ ] Growing  [ ] Flat  [ ] Declining

MARKET SIGNALS:
1. Is search volume for your keywords growing or declining?
   [ ] Growing → market is expanding (patience may pay)
   [ ] Flat → market is mature (differentiate or exit)
   [ ] Declining → market is contracting (exit unless you dominate a niche)

2. Are competitors entering or leaving?
   [ ] New competitors arriving → market is validated but getting crowded
   [ ] Competitors leaving → either market is dying or you'll inherit their customers
   [ ] No change → stable market, growth depends on your execution

3. Has the platform/technology you depend on changed direction?
   [ ] No changes → stable foundation
   [ ] Minor changes (pricing, features) → adapt and continue
   [ ] Major changes (deprecation, acquisition, pivot) → seriously evaluate exit

DECISION:
- If revenue is growing AND market signals are positive → KEEP (invest more)
- If revenue is flat AND market signals are positive → ITERATE (change approach, not product)
- If revenue is flat AND market signals are neutral → SET DEADLINE (90 days to show growth or kill)
- If revenue is declining AND market signals are negative → KILL (the market has spoken)
- If revenue is declining AND market signals are positive → your execution is the problem, not the market — fix or find someone who can

The hardest kill: When you're emotionally attached to a stream that the market doesn't want. You built it beautifully. The code is clean. The UX is thoughtful. And nobody is buying it. The market doesn't owe you revenue because you worked hard. Kill it, extract the lessons, and redirect the energy. The skills transfer. The code doesn't have to.

Lesson 6: Your 2026 Opportunity Radar

"A plan you wrote down beats a plan in your head. Every time."

The Deliverable

This is it — the output that makes this module worth your time. Your 2026 Opportunity Radar documents the three bets you're making this year, with enough specificity to actually execute on them.

Not five bets. Not "a few ideas." Three. Humans are terrible at pursuing more than three things simultaneously. One is ideal. Three is the maximum.

Why three?

• Opportunity 1: Your primary bet. This gets 70% of your effort. If only one of your bets succeeds, this is the one you want it to be.
• Opportunity 2: Your secondary bet. This gets 20% of your effort. It's either a hedge against Opportunity 1 failing or a natural complement to it.
• Opportunity 3: Your experiment. This gets 10% of your effort. It's the wild card — something earlier on the adoption curve that might be huge or might fizzle.

The Template

Copy this. Fill it in. Print it and tape it to your wall. Open it every Monday morning. This is your operating document for 2026.

# 2026 Opportunity Radar
# [Your Name]
# Created: [Date]
# Next Review: [Date + 90 days]

---

## Opportunity 1: [NAME] — Primary (70% effort)

### What It Is
[One paragraph describing exactly what you're building/selling/offering]

### Why Now
[Three specific reasons this opportunity exists TODAY and not 12 months ago]
1.
2.
3.

### My Competitive Advantage
[What do you have that makes you better positioned than a random developer?]
- Skill advantage:
- Knowledge advantage:
- Network advantage:
- Timing advantage:

### Revenue Model
- Pricing: [Specific price point(s)]
- Revenue target Month 1: $[X]
- Revenue target Month 3: $[X]
- Revenue target Month 6: $[X]
- Revenue target Month 12: $[X]

### 30-Day Action Plan
Week 1: [Specific, measurable actions]
Week 2: [Specific, measurable actions]
Week 3: [Specific, measurable actions]
Week 4: [Specific, measurable actions]

### Success Criteria
- DOUBLE DOWN signal: [What would make you increase effort?]
  Example: "3+ paying customers in 60 days"
- PIVOT signal: [What would make you change approach?]
  Example: "0 paying customers after 90 days despite 500+ views"
- KILL signal: [What would make you abandon this entirely?]
  Example: "A major platform announces a free competing feature"

---

## Opportunity 2: [NAME] — Secondary (20% effort)

### What It Is
[One paragraph]

### Why Now
1.
2.
3.

### My Competitive Advantage
- Skill advantage:
- Knowledge advantage:
- Relationship to Opportunity 1:

### Revenue Model
- Pricing:
- Revenue target Month 3: $[X]
- Revenue target Month 6: $[X]

### 30-Day Action Plan
Week 1-2: [Specific actions — remember, this gets only 20% effort]
Week 3-4: [Specific actions]

### Success Criteria
- DOUBLE DOWN:
- PIVOT:
- KILL:

---

## Opportunity 3: [NAME] — Experiment (10% effort)

### What It Is
[One paragraph]

### Why Now
[One compelling reason]

### 30-Day Action Plan
[2-3 specific, small experiments to validate the opportunity]
1.
2.
3.

### Success Criteria
- PROMOTE to Opportunity 2 if: [what would need to happen]
- KILL if: [after how long with no traction]

---

## Quarterly Review Schedule

- Q1 Review: [Date]
- Q2 Review: [Date]
- Q3 Review: [Date]
- Q4 Review: [Date]

At each review:
1. Check success criteria for each opportunity
2. Decide: double down, pivot, or kill
3. Replace killed opportunities with new ones from your intelligence log
4. Update revenue targets based on actual performance
5. Adjust effort allocation based on what's working

A Completed Example

Here's a realistic, filled-in Opportunity Radar so you can see what a good one looks like:

# 2026 Opportunity Radar
# Alex Chen
# Created: 2026-02-18
# Next Review: 2026-05-18

---

## Opportunity 1: MCP Server Bundle for DevOps — Primary (70%)

### What It Is
A pack of 5 MCP servers that connect AI coding tools to DevOps
infrastructure: Docker management, Kubernetes cluster status,
CI/CD pipeline monitoring, log analysis, and incident response.
Sold as a bundle on Gumroad/Lemon Squeezy, with a premium
"managed hosting" tier.

### Why Now
1. MCP ecosystem is early — no DevOps-focused bundle exists yet
2. Claude Code and Cursor are adding MCP support to enterprise plans
3. DevOps engineers are high-value users who will pay for tools that
   save time during incidents

### My Competitive Advantage
- Skill: 6 years of DevOps experience (Kubernetes, Docker, CI/CD)
- Knowledge: I know the pain points because I live them daily
- Timing: First comprehensive DevOps MCP bundle

### Revenue Model
- Bundle price: $39 (one-time)
- Managed hosting tier: $15/month
- Revenue target Month 1: $400 (10 bundle sales)
- Revenue target Month 3: $1,500 (25 bundles + 20 managed)
- Revenue target Month 6: $3,000 (40 bundles + 50 managed)
- Revenue target Month 12: $5,000+ (managed tier growing)

### 30-Day Action Plan
Week 1: Build Docker MCP server + Kubernetes MCP server (core 2 of 5)
Week 2: Build CI/CD and log analysis servers (servers 3-4 of 5)
Week 3: Build incident response server, create landing page, write docs
Week 4: Launch on Gumroad, post on HN Show, tweet thread, r/devops

### Success Criteria
- DOUBLE DOWN: 20+ sales in first 60 days
- PIVOT: <5 sales in 60 days (try different positioning or distribution)
- KILL: A major platform (Datadog, PagerDuty) ships free MCP servers
  for their products

---

## Opportunity 2: Local AI Deployment Blog + Consulting — Secondary (20%)

### What It Is
A blog documenting local AI deployment patterns with real
configurations and benchmarks. Generates consulting leads.
Blog posts are free; consulting is $200/hr.

### Why Now
1. EU AI Act transparency obligations just hit (Feb 2026)
2. Content about LOCAL deployment (not cloud) is scarce
3. Every blog post is a permanent consulting lead magnet

### My Competitive Advantage
- Skill: Already running local LLMs in production at day job
- Knowledge: Benchmarks and configs nobody else has published
- Relationship to Opp 1: MCP servers demonstrate competence

### Revenue Model
- Blog: $0 (lead generation)
- Consulting: $200/hr, target 5 hrs/month
- Revenue target Month 3: $1,000/month
- Revenue target Month 6: $2,000/month

### 30-Day Action Plan
Week 1-2: Write and publish 2 high-quality blog posts
Week 3-4: Promote on LinkedIn, engage in relevant HN threads

### Success Criteria
- DOUBLE DOWN: 2+ consulting inquiries in 60 days
- PIVOT: 0 inquiries after 90 days (content isn't reaching buyers)
- KILL: Unlikely — blog posts compound regardless

---

## Opportunity 3: Agent-to-Agent Protocol Experiment — Experiment (10%)

### What It Is
Exploring agent-to-agent communication patterns — building a
prototype where one MCP server can discover and call another.
If agent commerce becomes real, early infrastructure builders win.

### Why Now
- Anthropic and OpenAI both hinting at agent interoperability
- This is 12-18 months early, but the infrastructure play is worth
  a small bet

### 30-Day Action Plan
1. Build two MCP servers that can discover each other
2. Prototype a billing mechanism (one agent paying another)
3. Write up findings as a blog post

### Success Criteria
- PROMOTE to Opportunity 2 if: agent interoperability protocol
  announced by any major player
- KILL if: no protocol movement after 6 months

---

## Quarterly Review: May 18, 2026

The Quarterly Review Ritual

Every 90 days, block 2 hours. Not 30 minutes — two hours. This is the most valuable planning time of the quarter.

Review agenda:

Hour 1: Assessment
  0:00 - 0:15  Review each opportunity's success criteria against actual results
  0:15 - 0:30  Review your intelligence log for emerging signals
  0:30 - 0:45  Assess: what changed in the market since last review?
  0:45 - 1:00  Honest self-assessment: what did I execute well? What did I drop?

Hour 2: Planning
  1:00 - 1:15  Decision for each opportunity: double down / pivot / kill
  1:15 - 1:30  If killing an opportunity, select a replacement from your intelligence log
  1:30 - 1:45  Update effort allocation and revenue targets
  1:45 - 2:00  Write next 90-day action plan for each opportunity

What most people skip (and shouldn't):

The "honest self-assessment" step. It's easy to blame the market when revenue targets aren't met. Sometimes the market is the problem. But more often, the problem is that you didn't execute the plan. You got distracted by a new idea, or you spent 3 weeks "perfecting" something instead of shipping it, or you just didn't do the outreach you said you'd do.

Be honest in your review. The Opportunity Radar only works if you update it with real data, not comfortable narratives.

Your Turn

1. Fill in the Opportunity Radar template. All three opportunities. All fields. Set a timer for 60 minutes.
2. Choose your primary opportunity from the seven in Lesson 2, informed by the timing analysis from Lesson 3, the intelligence system from Lesson 4, and the future-proofing lens from Lesson 5.
3. Complete your 30-day action plan for Opportunity 1 with weekly milestones. These should be specific enough that you can check them off. "Work on MCP server" is not specific. "Publish MCP server to npm with README and 3 example configs" is specific.
4. Schedule your first quarterly review. Put it on your calendar. Two hours. Non-negotiable.
5. Share your Opportunity Radar with one person. Accountability matters. Tell a friend, a colleague, or post it publicly. "I'm pursuing [X], [Y], and [Z] this year. Here's my plan." The act of declaring your bets publicly makes you far more likely to follow through.

Module E: Complete

What You've Built in Week 11

You now have something that most developers never create: a structured, evidence-based plan for where to invest your time and energy this year.

Specifically, you have:

1. A current landscape assessment — not generic "AI is changing everything" platitudes, but specific knowledge of what changed in 2026 that creates income opportunities for developers with local infrastructure.
2. Seven evaluated opportunities with specific revenue potential, competition analysis, and action plans — not abstract categories but actionable businesses you could start this week.
3. A timing framework that prevents you from entering markets too early or too late — plus the signals to watch for each.
4. A working intelligence system that surfaces opportunities automatically instead of relying on luck and browsing habits.
5. A future-proofing strategy that protects your income against the inevitable shifts coming in 2027 and beyond.
6. Your 2026 Opportunity Radar — the three bets you're making, with success criteria and a quarterly review cadence.

The Living Module Promise

This module will be rewritten in January 2027. The seven opportunities will change. Some will be upgraded (if they're still hot). Some will be marked "window closing." New ones will be added. The timing framework will be recalibrated. The predictions will be audited against reality.

If you bought STREETS Core, you get the updated Evolving Edge module every year at no additional cost. This is not a course you complete and shelve — it's a system you maintain.

What Comes Next: Module T2 — Tactical Automation

You've identified your opportunities (this module). Now you need to automate the operational overhead so you can focus on execution instead of maintenance.

Module T2 (Tactical Automation) covers:

• Automated content pipelines — from intelligence gathering to published newsletter with minimal manual intervention
• Client delivery automation — templated proposals, automated invoicing, scheduled deliverables
• Revenue monitoring — dashboards that track income per stream, cost per acquisition, and ROI in real-time
• Alert systems — get notified when something needs your attention (market shift, client issue, opportunity signal) instead of checking manually
• The "4-hour workweek" for developer income — how to reduce operational overhead to under 4 hours per week so the rest of your time goes to building

The goal: maximum income per hour of human attention. Machines handle the routine. You handle the decisions.

4DA Integration

This is where 4DA becomes indispensable.

The Evolving Edge module tells you WHAT to look for. 4DA tells you WHEN it's happening.

Semantic shift detection notices when a technology is crossing from "experimental" to "production" — exactly the signal you need to time your entry. Signal chains track the story arc of an emerging opportunity across days and weeks, connecting the HN discussion to the GitHub release to the job posting trend. Actionable signals classify incoming content into the categories that match your Opportunity Radar.

You don't need to check manually. You don't need to maintain 10 RSS feeds and a Twitter list. 4DA surfaces the signals that matter to YOUR plan, scored against YOUR Developer DNA, delivered in YOUR daily briefing.

Set up your 4DA sources to match the intelligence stack from Lesson 4. Configure your Developer DNA to reflect the opportunities in your Radar. Then let 4DA do the scanning while you do the building.

The developer who checks signals 15 minutes per day with 4DA catches opportunities before the developer who spends 2 hours per day browsing Hacker News without a system.

Intelligence is not about consuming more information. It's about consuming the right information at the right time. That's what 4DA does.

Your Opportunity Radar is your compass. Your intelligence system is your radar. Now go build.

This module was written February 2026. The 2027 edition will be available January 2027. STREETS Core purchasers receive annual updates at no additional cost.

Your rig. Your rules. Your revenue.