The Solopreneur Wave Is Coming and Most People Aren't Ready

Five years ago, if you wanted to build a SaaS product that searched 480,000+ trademark records using phonetic matching algorithms, you needed a team. A backend engineer for the search infrastructure. A frontend developer. Someone who understood IP law well enough to define the matching rules. A DevOps person to keep it running. Maybe a product manager to coordinate everyone. That's 3-5 people, six figures in payroll before you've found a single customer.

I built Markatzy - exactly that product, serving major IP law firms - by myself. Not because I'm exceptional. Because the tools changed.

And I think what happened to me is about to happen to thousands of other people who have deep domain knowledge and a problem worth solving. The wave of one-person software companies is coming faster than most people expect.

The Bottleneck Was Never Code

Here's the thing almost nobody talks about when they discuss AI and software development: the hard part of building software was never writing the code. It was the coordination.

Think about what actually slows down a 10-person engineering team. Standups. Sprint planning. Architecture alignment meetings. Pull requests sitting in a queue waiting for review. The backend team blocking the frontend team because the API isn't ready. The designer changing specs mid-sprint. The new hire who needs three weeks of onboarding before they're productive. Context switching between Slack, Jira, Figma, and the actual codebase.

A study from Stripe in 2019 found that developers spend only 32% of their time actually writing code. The rest is meetings, maintenance, and waiting. That's not a technology problem. That's a human communication problem.

A solo developer with AI tooling has zero communication overhead. Zero. No Slack threads. No standups. No waiting for someone to review your PR. No misaligned understanding of requirements because you are the requirements. You build systems around the AI - persistent instructions, automated guardrails, parallel worktrees - and you just work.

The speed difference is not 2x or 3x. It's an order of magnitude. Not because one person writes code faster than a team, but because one person has no coordination tax. And coordination tax compounds. Every person you add to a team increases the communication paths quadratically. Brooks's Law from 1975 was right, and AI just made it more relevant, not less.

Enterprises Are Trapped by Their Own Success

The second part of this thesis is about who can't move fast, even with AI.

Large companies with established products are trapped by their own users. Every change they make risks breaking something for millions of people. They need migration paths, backwards compatibility, legal review, accessibility audits, localization in 40 languages, and 14 people who need to approve a color change. They have multiple products that depend on each other, shared databases, internal APIs that dozens of teams consume, and architecture decisions from 2018 that nobody wants to touch but everyone depends on.

This isn't dysfunction. It's the natural consequence of success at scale. When you have paying customers depending on specific behavior, moving fast is irresponsible. You earn the right to be slow by having things people rely on.

A solopreneur on day one has zero users and zero dependencies. You can ship breaking changes every hour and nobody cares. You can rip out your entire database schema at 2 AM and rebuild it by morning. You can pivot the product direction based on a conversation with one customer. You can deploy to production fifteen times a day without a change advisory board.

That speed advantage is enormous in the early stages of a product. It means a solo developer can find product-market fit in the time it takes an enterprise to finish their planning phase. And once you've found it, you have a head start that's genuinely difficult to close - because now the enterprise has to build and migrate simultaneously while you're already iterating with real users.

The Compliance Argument Everyone Gets Wrong

The objection I hear most often is: "Sure, one person can build something, but they can't serve enterprise customers. Enterprises require SOC 2, ISO 27001, security reviews. That's impossible for a solo developer."

I saw the SOC 2 process from the inside at Kriptos. I know what the audit looks like with a full team. And here's the counterintuitive truth: compliance actually gets easier when you're one person.

Think about what disappears from a SOC 2 audit when there's one person with one laptop:

The entire "People" trust service criteria section - which is typically one of the most complex parts of a SOC 2 audit - becomes almost trivial. What remains is infrastructure security, encryption, logging, incident response, and vendor management. And honestly, most of that is handled by default if you're on Vercel or Railway, with managed Postgres and GitHub. The cloud providers have done the heavy lifting.

The separation of duties objection is the one auditors push hardest on, and it's weaker than it looks. The concern is that the person writing the code is also reviewing it, deploying it, and monitoring production. But AI code review via GitHub Actions, automated test suites, protected branches with mandatory status checks, and infrastructure-as-code with full audit trails might actually provide better oversight than a tired colleague rubber-stamping a PR on a Friday afternoon.

I've seen companies with full teams game the SOC 2 process - passing audits with the right org chart while cutting corners behind the scenes. A solo operator with genuine automated controls and clean audit trails might actually be more trustworthy. The controls are harder to circumvent when they're enforced by machines rather than policies that depend on humans following them.

The Compliance Industry Isn't Ready

Here's an opportunity hiding in plain sight: the compliance consulting industry is built for companies with 20-50+ employees. Their processes, their pricing, their questionnaires, their evidence collection templates - all designed for organizations with organizational complexity.

Most SOC 2 prep firms charge $30,000-$50,000 because their process assumes you have:

• Multiple teams with different access levels
• An HR department managing onboarding and offboarding
• A security team separate from the engineering team
• Complex vendor relationships across departments
• Role-based access control matrices spanning dozens of people

A solopreneur walks in and half their checklist is "not applicable." But the firm still charges the same rate because they haven't built a streamlined process for one-person companies.

The consultants who figure out an affordable, fast package for solo and micro-team SaaS companies will capture a huge emerging market. The budget compliance stack already exists - platforms like TrustCloud (free for companies under 20 employees) and Comp AI ($3,000/year) make the tooling accessible. What's missing is the consulting layer that actually understands how a one-person company operates.

And AI makes the remaining compliance work easier too. Writing security policies, generating evidence documentation, maintaining audit trails, monitoring infrastructure for drift - that's exactly the kind of repetitive, structured work that AI handles well. You could probably maintain continuous compliance with a few automated workflows and a quarterly self-review.

The Five Filters

Here's where I need to be honest. Can everyone do this? Probably not. The tooling is accessible to anyone with a credit card, but the bottleneck isn't the tooling anymore. It's the person.

There are five filters that eliminate most people, and you need to pass all of them.

Filter 1: Domain expertise

You need to deeply understand a problem worth solving. Not "I read a blog post about the industry" deep, but "I've worked in this for years, I know where the pain is, I know who pays for solutions and how much" deep. This is why you see thousands of AI wrappers and developer tools but very few people building for veterinary clinics or customs brokerage. Most developers don't have domain expertise outside of tech itself. The people who do - the insurance adjuster who can code, the logistics coordinator who understands databases, the lawyer who builds software - those are the ones positioned to capture niche markets.

Filter 2: Technical range

You need to be genuinely full-stack. Not just frontend or backend, but database design, infrastructure, auth, payments, deployment, monitoring. AI accelerates all of this, but you still need to evaluate its output, debug when it goes wrong, and make architectural decisions it can't make for you. Most people who call themselves developers are specialists in one layer. That's fine for employment, but solo means you own the whole stack.

Filter 3: Tolerance for ambiguity

Building a product alone means you're simultaneously the PM, designer, developer, QA, sales, support, and accountant. There's no sprint board someone else populated with tickets. You wake up and decide what matters today. Most people genuinely don't function well like that - not because they're lazy, but because they're wired for structure and collaboration. And that's fine. It just means this path isn't for them.

Filter 4: The business side

This one kills the most technical people. You can build the perfect product and nobody cares because you don't know how to find customers, price it, position it, close a deal, handle churn. My legal background means I'm comfortable talking to lawyers and firms as peers, not as a developer trying to sell to an alien species. That domain fluency in the sales conversation is as important as the technical fluency in the codebase.

Filter 5: Emotional endurance

Solo means alone. No cofounder to share the doubt with at 11 PM when nothing is working and you have zero new signups this week. The AI doesn't care about your morale. Most people quit not because the technical problem was too hard but because the loneliness and uncertainty wore them down. This filter is invisible from the outside and probably the hardest to train for.

When you stack all five - domain expertise, technical range, ambiguity tolerance, business instinct, emotional resilience - the number of people who pass all of them is small. Maybe a few percent of developers. Maybe less.

But a few percent of a rapidly growing population of AI-literate builders is still a lot of people in absolute terms. And each one can now do what previously took a team. A thousand solopreneurs each capturing a $500K niche is half a billion dollars of value that didn't exist before, created with essentially zero venture capital.

Where Solopreneurs Win

The sweet spot is niche, domain-specific problems where you need deep expertise to even understand what to build.

Think about the pattern: someone who has spent 10 years in insurance claims processing knows exactly which workflows are broken, which reports take too long, which integrations don't exist. Someone who has worked in veterinary billing knows the pain points that generic software doesn't address. Someone with deep experience in construction permitting, agricultural compliance, freight logistics, pharmaceutical supply chains - they all have the same advantage.

These are markets where the total addressable market looks too small to justify a VC-funded startup with a 15-person team. A $500,000/year niche SaaS doesn't excite investors. But for one person? That's life-changing revenue with incredible margins. And because the market is too small for big companies to care about, you face almost no competition from well-funded teams.

This is exactly what happened with Markatzy. The intersection of trademark law and phonetic matching algorithms is a tiny market. No VC would fund a team to build it. But for one person with the domain expertise to understand what IP lawyers actually need, it's a real business serving real clients.

The moat isn't code. AI commoditizes code. The moat is knowing which problem to solve and for whom. That comes from years of domain experience that no language model can replicate.

Why Latin America Is Fertile Ground

Where I think this wave will hit especially hard is Latin America. The combination of factors is almost uniquely favorable.

Lower cost of living makes smaller revenue viable. A $200K/year SaaS that wouldn't cover rent in San Francisco is transformative income in Quito, Bogota, or Mexico City. The revenue threshold for a sustainable one-person business drops dramatically, which means smaller niches become viable businesses.

Underserved vertical markets. LATAM industries - banking regulation, customs clearance, agricultural export compliance, mining permits, IP law - have specific regulatory requirements that global SaaS products don't address. The compliance landscape is different country by country, and nobody in Silicon Valley is building for it because they don't understand it.

Regulatory complexity that outsiders can't navigate. This is the moat. A developer in Austin can't build software for Ecuadorian trademark law because they don't understand the SENADI filing process, the regional classification quirks, or the phonetic matching rules that Latin American examiners actually apply. That regulatory knowledge is the barrier to entry, and it's measured in years, not weeks.

Growing tech literacy. The pool of technically capable people in LATAM is expanding fast. Bootcamps, university programs, and remote work exposure to international codebases have created a generation that can build real software. What most of them lack isn't coding ability - it's the confidence and the business instinct to build for their own market instead of working for someone else's.

A bilingual developer who understands both LATAM regulatory frameworks and modern software architecture is a genuinely rare profile. There aren't that many people who can read a Superintendencia banking regulation and then implement the compliance logic in TypeScript the same afternoon. But the ones who exist are sitting on more potential than they realize.

Where It Gets Harder

I'd be dishonest if I said this works everywhere. There are real limits.

Trust-sensitive verticals. Products handling financial transactions, medical records, or national security data face scrutiny that goes beyond SOC 2 checklists. Customers in these spaces often want to see a real team, real offices, real organizational depth. One person running a critical healthcare integration from a laptop is a harder sell, regardless of how clean the audit trail is.

Products that require 24/7 support. If your customers expect someone to answer the phone at 3 AM, being solo is a genuine constraint. You can mitigate this with monitoring, automation, and AI-assisted support - but some buyers need a human on call, and one human can only be on call so many hours.

Scale inflection points. A solo developer can build and maintain a product serving hundreds of customers. Thousands, even, with the right architecture. But at some point, the operational load - support tickets, billing issues, feature requests, infrastructure maintenance - exceeds what one person can handle regardless of tooling. The question is whether you want to grow past that point, and many niche products don't need to.

Network effect products. If your product's value depends on having millions of users - social networks, marketplaces, communication platforms - a solo developer can build the technology but can't solve the chicken-and-egg problem of user acquisition. That still requires marketing, partnerships, and often capital.

The Wave Is Already Here

The explosion of one-person software companies is already happening quietly. People with deep knowledge in specific industries are realizing that the problem they've been complaining about for years is now solvable in weeks instead of months. They don't need to raise funding. They don't need to hire a team. They need a laptop, domain expertise, and the willingness to build.

Most of them just don't know it yet. Which is itself an opportunity - the first people in each niche who figure this out will have a structural advantage that's hard to replicate. Not because the code is special, but because they got to market first with a product built by someone who actually understands the problem.

The economics of software have fundamentally shifted. The minimum viable team for a real, revenue-generating SaaS product has dropped from 5 people to 1. The cost of reaching enterprise-grade compliance has dropped from $50,000+ to under $10,000. The time from idea to deployed product has collapsed from months to weeks.

What hasn't changed is the value of knowing what to build. Domain expertise is the new moat. Agentic engineering gives you leverage to build it. And if you're someone who has spent years accumulating deep knowledge in a specific industry, you're sitting on more potential than you realize.

The tools are ready. The markets are waiting. The only question is who moves first.

Keep reading:

• The Secret Sauce Isn't Better Prompts: How I Actually Use AI Coding Assistants
• The Agentic Architect: Lessons from the OpenClaw Workflow
• Compliance Certifications for Solo Developers: What's Actually Possible

Thinking about building a solo SaaS in your niche? Let's talk.