Skip to main content

· 8 min read
Arkin Eliezer Julijanto

Meta Description: A founder runs multiple profitable SaaS companies spending just $20/month on infrastructure. Here's the lean tech stack playbook — single VPS, Go, SQLite, and local AI.

The Bootstrapper's Dilemma​

Here's a story that sounds familiar: a founder walks into a pitch meeting. They have real users, real MRR, real product traction. The VC's response? "What do you even need funding for?"

That's exactly what happened to Steve Hanov — the creator of websequencediagrams.com and several niche SaaS products. His costs are so low that VCs can't figure out what to fund. And that's the point.

In 2026, the default startup playbook says: spin up AWS, provision EKS clusters, configure RDS instances, set up NAT Gateways, and accidentally burn $300/month before your first user even loads the landing page. The lean playbook says: rent a $5 VPS, compile a static binary, ship it.

One approach buys you a maze of managed services. The other buys you infinite runway.

The $20/Month Stack, Deconstructed​

Hanov's approach isn't about being cheap for its own sake. It's about keeping the architecture so simple that you spend your time solving user problems instead of debugging infrastructure. Here's what the stack looks like:

One Server, One Binary​

No Kubernetes. No container orchestration. No microservices talking to microservices. A single VPS from Linode or DigitalOcean at $5-10/month. 1GB of RAM with a swapfile if needed.

The backend? Written in Go, compiled into a single statically-linked binary on a laptop, SCP'd to the server, and run. No dependency hell, no virtual environments, no pip install nightmares. The deployment process is literally:

GOOS=linux go build -o app .
scp app root@yourserver:/opt/app/
ssh root@yourserver 'systemctl restart app'

A basic Go HTTP server handles tens of thousands of requests per second on potato hardware. No framework required.

SQLite Over Postgres​

This is the part that makes most developers flinch. SQLite — in production? For a real SaaS?

Yes. And here's why it works:

  • A local .db file communicating over the C-interface is orders of magnitude faster than making a TCP network hop to a remote Postgres server
  • Enable Write-Ahead Logging (WAL) with two pragmas, and readers don't block writers, writers don't block readers
  • On an NVMe drive, a single SQLite file handles thousands of concurrent users
PRAGMA journal_mode=WAL;
PRAGMA synchronous=NORMAL;

The enterprise mindset says you need an out-of-process database server. The lean mindset says: your database is a file on a disk, and that's a feature, not a bug. No connection pooling, no network latency, no separate server to manage and monitor.

Local AI Instead of API Bills​

This is where it gets really interesting. Hanov runs batch AI workloads — deep stock market research, summarizing thousands of quarterly reports — on a used RTX 3090 bought from Facebook Marketplace for $900. No OpenAI API bills. No rate limits. No "logic bug in my prompt loop that cost me $200 before I noticed."

The upgrade path is pragmatic:

  1. Start with Ollama — one command to spin up any model, perfect for iterating on prompts
  2. Move to vLLM for production — PagedAttention makes it dramatically faster for concurrent batch requests. Send 16 async requests and they all finish in roughly the time of one
  3. Transformer Lab for fine-tuning — when you need to customize models on local hardware

For frontier model tasks that can't run locally (user-facing chat, complex reasoning), he uses OpenRouter as a single API gateway to every major model. One integration, automatic fallback routing — if Anthropic goes down, it falls back to OpenAI. Users never see errors.

The Copilot Hack​

Here's a detail that resonates with any developer watching their AI tooling costs: Hanov uses a standard GitHub Copilot subscription (~$10-20/month) plugged into vanilla VS Code. Not Cursor. Not Windsurf. Not a $200/month API habit.

The trick: Copilot charges per request, not per token. So a brutally detailed prompt that tells the agent to "keep going until all errors are fixed" while it spends 30 minutes chewing through an entire codebase still costs roughly $0.04. Write good prompts with strict success criteria, hit enter, and let Microsoft subsidize your compute.

Why This Matters in 2026​

The timing of this playbook matters. Three trends are converging:

AI has collapsed the cost of building. A solo founder with good prompting skills and a $5 server can now build what took a 5-person team two years ago. The bottleneck isn't engineering capacity — it's finding the right problem.

VCs are asking harder questions about burn. The zero-interest-rate era of "growth at all costs" is over. Investors want to see capital efficiency. A founder who can demonstrate $10K MRR on $20/month infrastructure has a fundamentally different conversation than one burning $50K/month on AWS.

Simple stacks survive longer. Every abstraction layer you add is a maintenance burden. Every managed service is a potential single point of failure and a definite line item. A single server with a single binary and a single database file is boring — and that's exactly why it works.

The Real Lesson: Constraints Create Focus​

Hanov's stack isn't just about saving money. It's about what happens when you remove infrastructure as a variable:

  • You know exactly where your logs are — they're on the one server
  • You know exactly why something crashed — it's the one binary
  • You know exactly how to fix it — restart the one process
  • You have infinite runway — $20/month means you can iterate for years

The traditional startup playbook optimizes for scale that hasn't arrived yet. The lean playbook optimizes for survival and learning. When you're pre-product-market-fit, survival and learning are the only metrics that matter.

You can always migrate to Kubernetes later, when you actually have the traffic that justifies it. But you can't undo the months of infrastructure complexity you built "just in case."

When Lean Stops Working​

To be fair — this approach has limits. The $20/month stack works beautifully up to a point. When you need:

  • Multi-region redundancy for enterprise SLAs
  • Complex relational queries across millions of rows
  • Real-time collaboration features (CRDTs, WebSockets at scale)
  • SOC 2 compliance and audit trails

...you'll eventually need to graduate beyond a single VPS and SQLite. But that's a good problem to have, and by the time you have it, you'll have the revenue to solve it properly.

The mistake is pre-optimizing for scale you haven't earned yet.

Conclusion​

Steve Hanov's $20/month stack is a reminder that the tech industry's default complexity is a choice, not a requirement. You can build real businesses — profitable ones — on simple, boring infrastructure.

A single VPS. A Go binary. SQLite with WAL. Local AI for batch work. OpenRouter for frontier models. Copilot for coding.

Total cost: less than a Spotify subscription.

The question isn't whether this stack can scale to millions of users. The question is: do you need to scale to millions of users before you've found ten who love your product?

Start lean. Graduate when the data tells you to. And enjoy the infinite runway.


FAQ​

Q: Can SQLite really handle a production SaaS with thousands of users? A: Yes, with WAL mode enabled. SQLite with Write-Ahead Logging allows concurrent reads and writes without blocking. On NVMe storage, it handles thousands of concurrent connections. It's used in production by companies like Turso and Fly.io for their own infrastructure.

Q: What's wrong with using AWS for a new startup? A: Nothing is wrong with AWS — but it encourages over-engineering from day one. Managed services, EKS clusters, and RDS instances add up fast ($300+/month before your first user). A $5 VPS forces you to keep things simple and gives you the same runway as a $1M seed round with a high burn rate.

Q: How do you handle database backups with SQLite? A: SQLite backups are just file copies. You can use the .backup command for consistent snapshots, or simply copy the .db file during low-traffic periods. Combine with S3 or any object storage for offsite backups — still well under $20/month total.

Q: Is local AI really practical for production workloads? A: For batch processing — research, summarization, data extraction — absolutely. A used RTX 3090 ($900 one-time) running vLLM can process thousands of inference requests without per-token API costs. For real-time user-facing features, you'd still want a cloud API for latency reasons.


About the Author: Arkin is a software engineer and startup founder building Orbits Studio. He writes about lean engineering, indie hacking, and building products without the enterprise bloat. Find him at arkin-dev.com.

· 7 min read
Arkin Eliezer Julijanto

Meta Description: Anthropic's Mythos found thousands of zero-days — but small open models recovered the same analysis at a fraction of the cost. The moat in AI security is the system, not the model.

The Mythos Moment​

On April 7, 2026, Anthropic announced Claude Mythos Preview and Project Glasswing — a $100M+ initiative to use a frontier AI model to autonomously find and patch zero-day vulnerabilities in critical software. The results were staggering: thousands of vulnerabilities across every major OS and web browser, including a 27-year-old bug in OpenBSD and a fully autonomous remote code execution exploit against FreeBSD.

It was a watershed moment for AI cybersecurity. The narrative was clear: you need the biggest, most expensive model to do real security research.

Then AISLE ran the same vulnerabilities through small, cheap, open-weights models.

The results? 8 out of 8 small models detected Mythos's flagship FreeBSD exploit. One of them had only 3.6 billion active parameters and costs $0.11 per million tokens. A 5.1B-active parameter model recovered the core exploitation chain of the 27-year-old OpenBSD bug.

This changes the conversation entirely.

What AISLE Actually Tested​

AISLE took the specific vulnerabilities Anthropic showcased in their Mythos announcement, isolated the relevant code, and ran them through a range of small and open-weights models. Three tests stood out:

Test 1 — FreeBSD NFS Remote Code Execution (CVE-2026-4747): Mythos's crown jewel — a 17-year-old bug giving unauthenticated root access via NFS. Every single model they tested, from Kimi K2 to Qwen3 32B to a tiny GPT-OSS-20b (3.6B active params), correctly identified the stack buffer overflow and assessed it as critical. Detection was commoditized.

Test 2 — OpenBSD SACK Analysis (27-year-old bug): This one required mathematical reasoning about signed integer overflow. Much harder. Most models struggled — but GPT-OSS-120b (5.1B active) recovered the full public chain. Kimi K2 got close with an A- grade.

Test 3 — OWASP False Positive Discrimination: A Java servlet that looks like SQL injection but isn't. This is the test that flipped the script entirely — small, cheap models outperformed frontier models. Claude Sonnet 4.5 confidently mistraced the data flow. GPT-OSS-20b at $0.11/M tokens got it right. DeepSeek R1 nailed it across four trials. OpenAI o3 gave the most nuanced answer of all.

The pattern is clear: there is no stable "best model for cybersecurity." The capability frontier is jagged. Rankings reshuffle completely depending on the task.

Why This Matters for Developers and Security Teams​

The Mythos narrative suggests you need a frontier model — expensive, proprietary, limited access — to do meaningful AI security work. The evidence says otherwise.

Here's what the AISLE research actually demonstrates:

  • Detection is cheap. A $0.11/M token model can spot a critical buffer overflow just as well as a model that costs 50-100x more. The FreeBSD exploit was detected by every model tested, regardless of size.
  • The system is the moat, not the model. Anthropic's own scaffold — launch containers, scan files, use ASan as a crash oracle, rank by attack surface, run validation — is the same kind of system others in the field have built. The value is in the orchestration, targeting, and validation pipeline, not the specific model.
  • Coverage beats precision. Because small models are sufficient for most detection work, you can deploy them broadly across entire codebases instead of carefully rationing an expensive model. A thousand adequate detectives searching everywhere will find more bugs than one brilliant detective guessing where to look.
  • False positive management is the real differentiator. The OWASP test showed that bigger models often worse at distinguishing real vulnerabilities from false alarms. In production security systems, drowning reviewers in noise is worse than missing some bugs — it's what killed curl's bug bounty program.

The Bigger Picture: AI Security Economics​

This research has implications beyond vulnerability research:

For startups and indie security teams: You don't need to wait for Mythos-level access or budget. Open-weights models wrapped in good engineering can produce production-grade results. AISLE has been doing exactly this since mid-2025 — 180+ externally validated CVEs across 30+ projects, including 15 CVEs in OpenSSL.

For the open-source ecosystem: The security of critical infrastructure shouldn't depend on a single company's proprietary model. When small open models can detect the same bugs, it democratizes security research and makes the ecosystem more resilient.

For AI strategy: The "jagged frontier" phenomenon isn't limited to cybersecurity. It suggests that across many specialized domains, the relationship between model size and capability is non-linear. Smart system design can compensate for — or even outperform — raw model scale.

What Good AI Security Systems Actually Need​

Based on AISLE's production experience, here's what matters more than model size:

  • Targeting intelligence: Knowing which files and functions to examine in a codebase with hundreds of thousands of files
  • Iterative validation: Hypothesis → test → refine loops that separate real bugs from noise
  • Maintainer trust: The metric that actually matters is whether project maintainers accept your findings and patches
  • Full-loop remediation: Discovery is only the first step. Verification, severity assessment, patch generation, and coordination close the loop

The OpenSSL CTO praised AISLE's work for "high quality reports and constructive collaboration throughout remediation." That trust is earned through the system, not the model.

Conclusion​

Anthropic's Mythos proved that AI cybersecurity is real and here. AISLE's research proved it doesn't require a monopoly.

The frontier is jagged. Small models can do big things when wrapped in the right system. For developers, security teams, and anyone building AI-powered tools, the takeaway is empowering: you don't need the biggest model. You need the best system.

The economics of AI security just got a lot more interesting — and a lot more accessible.


FAQ​

Q: Can small AI models really replace frontier models for security research? A: Not replace — complement. AISLE's research shows small models can detect many of the same vulnerabilities as frontier models at a fraction of the cost. But the full pipeline (discovery, triage, validation, remediation) requires orchestration. The system matters more than any individual model.

Q: What is the "jagged frontier" in AI cybersecurity? A: It means AI capability doesn't scale smoothly with model size. A tiny 3.6B-parameter model might outperform a frontier model on one task and fail completely on another. There's no single "best" model across all cybersecurity tasks — rankings reshuffle depending on what you're testing.

Q: How are companies using small AI models for vulnerability detection? A: AISLE has been running a production system since mid-2025 using model-agnostic pipelines. They've found 180+ externally validated CVEs across 30+ projects including OpenSSL and curl. Their approach deploys cheap models broadly for coverage rather than rationing expensive models selectively.

Q: Should I use open-weights models instead of proprietary ones for security tooling? A: It depends on your use case. For detection and triage, open-weights models are often sufficient and far more cost-effective. For complex exploit construction requiring multi-step reasoning, larger models may still have an edge. The best approach is model-agnostic — use whatever works best for each specific task.


About the Author: Arkin is a software engineer and startup founder building Orbits Studio. He writes about AI, developer tools, and the intersection of technology and security. Find him at arkin-dev.com.

· 6 min read
Arkin Eliezer Julijanto

The AI agent wave isn't coming — it's already here, and it's bringing friends. This week's tech news roundup covers the quietest cost hike you've never heard of, two open-source agent platforms that could reshape how dev teams operate, a bootstrapper's $20/month playbook that embarrassed a VC, and a design essay that hit 300+ points on Hacker News. If you're building products or managing teams in 2026, these stories are your weekend homework.

· 7 min read
Arkin Eliezer Julijanto

AI tutoring tools have been everywhere lately. Most of them are just ChatGPT wrappers with a different skin — ask a question, get an answer, move on. Nothing sticks. Nothing adapts. Nothing remembers.

DeepTutor, built by the HKUDS team at Hong Kong University, takes a fundamentally different approach. It's an agent-native, open-source learning platform that builds a persistent profile of how you learn, what you've studied, and where you're heading — then uses that context across every interaction.

It hit 10,000 GitHub stars in 39 days. The v1.0.0 release just dropped with a ground-up architecture rewrite (~200k lines). This isn't a weekend side project. It's infrastructure.

· 7 min read
Arkin Eliezer Julijanto

Linus Torvalds merged something quietly significant into the Linux kernel tree: an official document titled AI Coding Assistants. It's not a policy debate. It's not a blog post. It's a .rst file sitting in Documentation/process/ right next to coding-style.rst and submitting-patches.rst.

The world's largest open-source project — 30+ million lines of code, thousands of contributors — just formally defined how AI can (and can't) participate in kernel development.

This isn't a niche Linux story. It's a blueprint that every engineering team dealing with AI-assisted code will eventually need.

· 6 min read
Arkin Eliezer Julijanto

AI agents aren't just trending on GitHub — they're absorbing entire companies. This week's tech news roundup covers OpenAI's quiet acquisition of a CI/CD pioneer, evidence that tiny models can go toe-to-toe with frontier AI in cybersecurity, and South Korea making mobile data a basic right. If you're building developer tools or running a startup that touches AI infrastructure, these stories are your Friday reading.

· 7 min read
Arkin Eliezer Julijanto

Foundation models have transformed natural language, images, and code. But financial markets? Not so much.

Until now.

Kronos is the first open-source foundation model trained specifically for the "language" of financial markets—K-line sequences (OHLCV data). Unlike general-purpose time-series models, Kronos understands the unique, high-noise characteristics of financial data. It's been trained on data from 45+ global exchanges, and it's already accepted by AAAI 2026.

This matters for anyone building fintech products, trading platforms, or quantitative systems. Domain-specific foundation models are the next frontier, and Kronos is proving it's possible for finance.

· 7 min read
Arkin Eliezer Julijanto

You're building a startup, watching every dollar like a hawk, and staring at cloud hosting bills that keep climbing. Your dev environment needs power, your staging server demands reliability, and production... well, production costs real money.

Meanwhile, that old laptop from 2019 sits in a drawer, gathering dust.

Here's the thing: thousands of bootstrapped founders are turning those forgotten laptops into collocated servers for a fraction of cloud costs. We're talking $5-15/month instead of $50-500/month for equivalent compute. You get full control, predictable pricing, and hardware that would otherwise be e-waste.

In this guide, I'll show you exactly how to repurpose old laptops as colo servers—from choosing hardware to finding facilities that accept laptops.

· 5 min read
Arkin Eliezer Julijanto

The AI agent wars are officially here, and open source is winning. While tech giants race to build proprietary coding assistants, the developer community is shipping open-source agent frameworks at breakneck speed. Today's tech news roundup shows a clear trend: developers want tools they can control, not black-box AI subscriptions.

· 5 min read
Arkin Eliezer Julijanto

You just joined a new team. Someone hands you a repo URL and says, "Get familiar with the codebase." What do you do?

Most developers start reading files from the top. They open src/, scroll through directories, and try to build a mental map folder by folder. That approach works—eventually—but it's slow, directionless, and leaves you guessing about the stuff that actually matters: where the problems live, who knows what, and whether the project is healthy or held together with duct tape.

Git has already been recording everything. Every bug fix, every refactor, every 3 AM hotfix—it's all sitting in the commit history, waiting to be read. You just need to know which questions to ask.

These five git commands take under two minutes to run and will tell you more about a codebase than a full day of browsing files.