DEV Community: Muhammad Akbar

How to build a SaaS for $100/month

Muhammad Akbar — Mon, 20 Jul 2026 19:11:16 +0000

You can run a production SaaS for $87/month using Neon (Postgres), Vercel (hosting), Supabase (auth), Resend (email), Plausible (analytics), and Polar.sh (payments). Each tool has a generous free tier that covers your first 500–1,000 users.

Hosting: Vercel — $0/mo (Hobby)

Vercel's free tier includes 100 GB bandwidth, 600 build minutes, and serverless function execution. For a bootstrapped SaaS with fewer than 10k monthly active users, this is genuinely free. You only pay when you need team features or dedicated infrastructure.

Database: Neon — $0/mo (Free tier)

Neon's free tier gives you 0.5 GB storage, 100 compute hours/month, and branching. The branch feature is a killer — spin up a copy of your production DB for every PR. At $25/mo (Scale), you get 10 GB storage and 500 compute hours, enough for most early-stage SaaS products.

Auth: NextAuth v5 — $0/mo

NextAuth v5 is open source and free. Host your own database sessions, or use Supabase Auth (also free up to 50k monthly active users).

Email: Resend — $0/mo (Free tier)

3,000 emails/month free. Transactional emails (welcome, password reset, invoice) typically consume 100–500 emails/month for early-stage SaaS. The $20/mo tier covers 50k emails.

Analytics: Plausible — $0/mo (Self-hosted)

Plausible is open source with a self-hosted option. Their cloud tier starts at $9/mo for 10k pageviews. Privacy-first, no cookie banners needed.

Payments: Polar.sh — 5% + $0.50/txn

Polar is the best option for developers outside Stripe-supported countries. They act as Merchant of Record, handle tax compliance, and pay out to your bank account.

The total

Service	Monthly Cost
Vercel (Hobby)	$0
Neon (Free)	$0
NextAuth (Open source)	$0
Resend (Free)	$0
Plausible (Self-hosted)	$0
Polar.sh (5% fee)	~$5 on $100 revenue
Domain	$1/mo
Total	~$6/mo until you scale

When you outgrow free tiers, expect ~$87/mo for production scale (10k+ MAU).

When to upgrade

500+ users: Upgrade Resend ($20/mo) for higher send limits
10k+ MAU: Upgrade Neon ($25/mo) for more compute hours
50k+ MAU: Upgrade Vercel Pro ($20/mo) for team features and higher limits

How I Built a Block Puzzle Game with React Native and Expo

Muhammad Akbar — Sat, 18 Jul 2026 00:48:14 +0000

How I Built a Block Puzzle Game with React Native and Expo

A few weeks ago, I launched my first mobile game — a block puzzle called Blockbeam. It's an 8x8 grid where you drag colorful blocks, fill rows and columns, and chase high scores. Simple concept, but building it taught me a lot about React Native's capabilities beyond typical CRUD apps.

Here's what I learned.

Why React Native for Games?

Most mobile games are built with Unity or native code. But for a 2D puzzle game, React Native is surprisingly capable. The game doesn't need 60fps 3D rendering — it needs gesture handling, state management, and smooth animations. React Native handles all three well.

The key stack:

Expo SDK 54 — managed workflow, over-the-air updates, zero native config
react-native-reanimated — 60fps drag animations
react-native-gesture-handler — PanResponder for drag-and-drop
react-native-svg — block rendering
AsyncStorage — game state persistence

The Puzzle Engine

The core of any block puzzle is the board state. I used a flat 64-element array for the 8x8 grid:

const BOARD = 8;
const CELLS = BOARD * BOARD; // 64
type Board = number[]; // 0 = empty, 1-7 = block colors

Piece placement is straightforward: check if all target cells are empty, fill them, then scan for complete rows and columns to clear.

The interesting part was the "greedy solver" I built for the auto-play bot. It tries every piece in every position and picks the move that clears the most lines:

for (const piece of tray) {
  for (let r = 0; r <= BOARD - piece.h; r++) {
    for (let c = 0; c <= BOARD - piece.w; c++) {
      if (!canPlace(board, piece, r, c)) continue;
      const score = simulateClear(board, piece, r, c);
      if (score > bestScore) { /* pick this move */ }
    }
  }
}

Drag and Drop with PanResponder

The trickiest part was the drag mechanic. Each tray piece has a PanResponder that tracks touch position and renders a floating ghost. On release, it calculates the nearest cell position:

const anchor = {
  col: Math.round((drag.x - boardLayout.x) / cell),
  row: Math.round((drag.y - LIFT - piece.h * cell - boardLayout.y) / cell),
};

The LIFT offset accounts for the finger being above the piece — a subtle UX detail that makes dragging feel natural.

What I'd Do Differently

Start with TypeScript — Caught dozens of bugs at compile time
Test on real devices early — Emulators don't reveal performance issues
Plan the theme system earlier — Adding palette switching after the fact was messy

The Result

The game is live on Google Play, completely free with no paywalls. 100% offline, 6 color themes, daily rewards, and power-ups.

If you're building a casual game, don't overthink the tech stack. React Native + Expo can take you surprisingly far.

Check it out: https://play.google.com/store/apps/details?id=com.magstudios.blockpuzzle

Built with React Native, Expo, and way too much coffee. Solo dev from Pakistan.

Postman now limits its free tier to 1 user. Here's what I switched to.

Muhammad Akbar — Sun, 07 Jun 2026 14:35:21 +0000

If you opened Postman recently and hit a wall sharing a collection with a teammate, you're not imagining it — as of March 2026, Postman's free tier is capped at 1 user. Solo, that's survivable. For a two-person side project it's an instant "upgrade to Team at $19/user/mo" prompt.

I write about cheap dev stacks, so I went through the actual alternatives and itemized what each gives you for free. Quick rundown:

Bruno — my pick if you live in Git. Collections are plain-text .bru files on disk (MIT-licensed, offline-first), so "sharing" is just committing to your repo. No accounts, no sync tier, secrets stay local. Postman, but you own your data.

Insomnia — the easiest like-for-like switch after the cutback. Kong-owned, open-source, and the free tier includes Git Sync for up to 3 users — actual free small-team collaboration.

Hoppscotch — web-based, MIT, with the widest protocol set (REST, GraphQL, WebSocket, SSE, Socket.IO, MQTT). Unlimited free real-time workspaces, and you can self-host the whole thing.

Thunder Client — if you basically live in VS Code and want something lightweight. Heads up: the free tier is single-device and paywalls environments, so it's more "personal" than "team."

The honest summary: want free team collaboration? Insomnia or Hoppscotch. Want to own your data / go Git-native? Bruno. Want lightweight in-editor? Thunder Client.

Full feature-by-feature breakdown (collections, environments, scripting, CLI/CI, self-host) here if you want the details: Postman alternatives compared →

What did you switch to after the free-tier change?

I built a dev review site in 2 weeks — here's the stack, the rejections, and what I'd do differently

Muhammad Akbar — Wed, 13 May 2026 16:20:03 +0000

A few months ago I tried to find a "best stack under 100 USD a month" article for a side project. Every result was either an enterprise list with line items at thousands per month, or a vague "use Vercel and Supabase" post with no actual numbers.

So I built one. The result is cheapstack.dev — an editorial site that publishes itemized reference stacks for indie SaaS infrastructure on 50–200 USD a month, with every line item, the date prices were verified, and what to swap when traffic crosses specific thresholds.

I'm not going to pretend this is a masterpiece. I want to write this post because the things I learned along the way will probably save someone else two weeks.

The build

Stack:

Next.js 16 with output: "export" for static export
Cloudflare Workers Static Assets for hosting (free, unlimited bandwidth)
IBM Plex Sans + Plex Mono for typography
Markdown-driven content layer (no CMS, no backend, no database)

Two-week evening build, mostly weekends. Lighthouse 100/100/100/100 across all pages.

Why Cloudflare Workers, not Vercel

Cheapstack's whole pitch is "real numbers for cheap stacks." Hosting it on Vercel — whose Hobby tier is explicitly non-commercial, and whose Pro tier starts at 20 USD a month — would have been hypocritical the moment I added an affiliate link.

Cloudflare Workers Static Assets bills 0 USD a month, even with commercial use, and edges out Vercel on first-byte latency in 60% of regions. The DX is rougher (you can't just next build and deploy — you need output: "export" and a wrangler config), but for a site that's truly static the trade is worth it.

I tried @opennextjs/cloudflare first because Cheapstack started life as a dynamic Next.js app with edge runtime OG images. Two days of debugging dynamic-route 404s later, I realized I didn't need any of that. Pre-generating the OG image as a 1200x420 PNG and switching to plain static export resolved everything in 30 minutes.

Lesson: if your site has no per-user state and no per-request logic, static export beats every adapter. Adapter complexity buys you flexibility you don't have.

The content layer

I went into this thinking I'd write everything from scratch. Then I realized the actual work was structuring the data so the prose was a thin layer on top.

Every tool on the site lives in one file:

// src/lib/tools.ts
type Tool = {
  slug: string;
  name: string;
  category: ToolCategory;
  pricing: { tier: string; usd: number; verified: string }[];
  affiliate: string | null;
  // ... more fields
};

export const TOOLS: Record<string, Tool> = {
  digitalocean: { ... },
  postmark: { ... },
  // ~70 tools
};

Stack guides, comparison pages, and tool roundups all pull from this single registry. When DigitalOcean changes their pricing, I update one entry and 11 pages reflect it. When an affiliate program approves me, I drop the tracking URL into the affiliate field and every link to that tool across the site updates.

This is mundane infrastructure but it's the difference between a site that decays in 3 months and a site that stays accurate for years.

Affiliate programs: the reality of being new

I applied to 12 affiliate programs in week one. Here's the score so far:

Program	Status
DigitalOcean (via Awin)	Declined — "site too new"
Squarespace (via Impact / Acceleration Partners)	Declined — "site not yet live or traffic levels below necessary"
Hostinger (direct)	Pending review, day 4 of 3–7
8 other Impact-network brands	Auto-deferred 30–60 days

So far: 0 approved, 2 declined, 1 pending, 9 deferred. The "site too new" pattern across every network was demoralizing — I'd built the whole monetization architecture on the assumption that applying with a live, polished site would be enough.

It's not. Affiliate networks gate on traffic signal, not site quality. The site needs to show up in Google for 30+ days with consistent search clicks before most programs unlock.

This was a real lesson: the FTC disclosures on cheapstack are mostly aspirational at the moment. Every tool link has rel="sponsored nofollow noopener" and a clear disclosure — even though most of them don't pay me anything. I left the architecture in because (a) when programs do approve me, the wiring is already there, and (b) the credibility hit of adding affiliate disclosures later would be worse than declaring intent on day one.

What's actually on the site

For the curious:

6 stack guides — itemized monthly bills for SaaS-100 (~87 USD/mo), MVP-50, marketplace-150, course-100, newsletter-25, landing-15
8 comparisons — Firebase vs Supabase, Postmark vs Resend, Beehiiv vs Ghost, Neon vs PlanetScale, Clerk vs Auth.js, Vercel vs Cloudflare Pages, Stripe vs Lemon Squeezy, Stripe vs Paddle
12 tool roundups — hosting, databases, transactional email, newsletter platforms, domain registrars, SEO tools, CRM, landing builders, payments, analytics, headless CMS, auth services
8 framework deep-dives — Next.js, Astro, SvelteKit, Remix, Nuxt, SolidStart, Qwik, RedwoodSDK

Everything's at cheapstack.dev if you want to see how it shipped.

Early signal

Four days post-launch, before any external traffic push:

Google Search Console: 41 impressions, position 12.1 average
Indexed: 8 of 47 pages (normal week-1 curve)
Most interesting query: "affordable node.js headless cms under 50/month" — exactly the kind of long-tail commercial-intent query the site was designed for

Position 12 means page 2 of Google. With backlinks and another month of indexing it could realistically move to page 1 for that query. That's the whole game.

What I'd do differently

Skip the OpenNext adapter entirely. Static export from day one. Two days saved.
Apply to affiliate programs only after 30 days of traffic. Day-one applications are a coin flip and rejection cool-down windows are 60–90 days.
Write less, structure more. The articles that are working are the ones with strong data tables and clean comparisons. Prose-heavy pieces sit in the middle of the rankings.
Start the newsletter on day one. I held off until "the site was ready." That was wrong. The newsletter is the only thing you actually own — everything else (Google rank, affiliate approvals, social reach) is rented from someone else.

What's next

More long-tail comparison pages targeting the queries already showing up in GSC
A weekly newsletter when I cross 100 organic visits/day
Real receipts from working indie builds (if you're running profitable on a 50–200 USD/mo stack, I'd love to feature your build — with permission)

If you've built anything similar — editorial site, affiliate engine, programmatic SEO play — I'd love to hear what worked and what didn't. The two-week timeline only worked because I made a lot of decisions fast; some of them are probably wrong.

Site: cheapstack.dev