The $175-a-Month Platform
Four client applications, a 336-endpoint API, 15 background services, ML forecasting, and 2,500+ generated pages — running on less than most phone bills, with the capacity math published
flowchart TB
subgraph NOW[Today: ~$175/mo]
N1[B-series app services +<br/>MySQL flexible + report VM<br/>~$125/mo Azure]
N2[Market-data license<br/>$50/mo minimum]
N3[Serves ~300-500 users]
end
subgraph WALL[First wall - known in advance]
W1[MySQL 171-connection cap<br/>pooling discipline required]
end
subgraph NEXT[One SKU step: ~$240/mo]
X1[DB + app tier upgrade]
X2[Serves ~1,500-2,500 users]
end
subgraph LATER[Beyond]
L1[Read replicas + caching<br/>absorb read load]
end
NOW --> WALL --> NEXT --> LATER
NOW -. static pre-generation:<br/>viral traffic = bandwidth,<br/>not compute .-> NOWThe Actual Bill
Production Azure runs at roughly $125/month — burstable B-series SKUs for the app services, the MySQL flexible server, and the report VM, plus blob storage and networking — with the commercial market-data license adding a $50/month minimum (usage-based above it). Total standing cost: ~$175/month. During the build there were two full environments (~$600/month); when the dev environment stopped earning its keep, it was deleted entirely — backups archived, IaC ready to recreate it in an afternoon if ever needed. Paying for idle infrastructure "just in case" is a habit, not a requirement.
The architecture is why the bill stays small: the modular monolith means one API deployment instead of a service fleet; batch work runs on one VM instead of always-on autoscalers; public surfaces (grade pages, shared-report shims, social cards) are pre-generated static files, so a viral moment costs bandwidth pennies rather than compute; and the database doubles as the job queue, which is one less product to rent.
Where We Are: Starting Small, On Purpose
Full transparency, consistent with everything else on this site: GMI is at the very start of its market journey. The platform is feature-complete, production-hardened, and dogfooded on real money — and we are just beginning to market it and earn traction. The infrastructure is sized for exactly that reality: small enough that waiting for the market costs almost nothing, architected so that growth is a configuration change, not a rebuild.
That's the strategic point of lean: a platform burning $20K/month must find its market this quarter; a platform at $175/month can be patient, iterate on what early users teach it, and turn the resource dial only when real demand — not optimism — asks for it.
The Growth Dial, Resource by Resource
Every Azure resource below scales independently — a SKU picker, not a migration. All of it is captured in infrastructure-as-code, so a capacity step is an edit, a review, and a deploy:
| Resource | Today | Carries | How it grows |
|---|---|---|---|
| MySQL Flexible Server | Burstable B-series | All 69 tables + the job queues; 171-connection cap — the first wall | One SKU step roughly doubles connections and memory; General-Purpose tiers and read replicas beyond that. The DB scales last and hardest, which is why it's watched first. |
| Functions API plan | Burstable B-series (Linux) | All 336 endpoints, auth + rate limiting, share/card rendering | Scale up (bigger SKU) or out (more instances) — stateless by design, so instances add linearly. Rate limiting already protects it from abuse-driven load. |
| Web App Services (client, admin, tech) | Basic tier | Static files + WASM bundles + 2,500 grade pages + social cards | Serving static bytes is the easiest job in the cloud — these tiers yawn at traffic. A CDN in front is the eventual step, and it's a bolt-on. |
| Report VM (worker fleet) | Burstable B-series | All 15 background services: report generation, ML, SEO/card builds, billing | Two independent dials: a bigger VM for heavier single jobs, or additional VMs polling the same job queue — the DB-as-queue design makes worker scale-out horizontal by nature. |
| Blob Storage | Standard (ZRS) | Reports, raw data, generated pages, cards | Effectively unlimited; cost tracks bytes. The one resource that never needs a decision. |
| Market-data license | $50/mo minimum, usage-based | Every report's fundamentals | Scales with revenue by construction — more paid reports means more API spend means more income. Tier steps are contractual and known in advance. |
The pattern across the whole table: nothing requires re-architecture until far past the thousands-of-users mark. The modular monolith deploys the same way at every size; static pre-generation means viral traffic hits storage, not compute; and the workers already scale horizontally. Azure's job is to sell us bigger numbers when we ask — the architecture's job was to make asking the only thing required.
The Capacity Math, Published
Lean is only impressive if it's honest about limits, so here they are. The current configuration comfortably serves an estimated 300–500 active users. The first wall is known in advance: the MySQL tier's 171-connection cap — every app, worker, and API instance draws from that pool, so connection pooling discipline (bounded pools, scoped contexts, no leaked connections) is a first-class engineering concern here, not an afterthought.
The upgrade path is priced, not vague: moving the database and app tiers one SKU step (~$240/month total) lifts capacity to an estimated 1,500–2,500 users. Beyond that, read replicas and caching absorb read load long before anything exotic is required. Scale-testing results and the load methodology are documented on the Scale Testing page — the same honesty rule as everywhere else on this site: numbers with provenance.
Why Unit Economics Work at Any Scale
- Marginal cost is metered, not fixed. The expensive actions — market-data API calls (~$0.065/symbol at commercial rates) and Claude analysis — are consumed per report and priced per report. Serving one more user costs pennies until they generate work, and generated work carries its own revenue.
- The free tier rides on already-paid data. Free users' dashboards read the global grade cache produced by the SEO refresh — grades computed once serve the public pages AND every free user, so free-tier marginal cost rounds to zero. (Full design: Free Tier Architecture.)
- Every cost has a name. Internal cost tracking records the data-vendor cost of every report generation against the account that incurred it — so gross margin per customer is a query, not a quarterly surprise.
- At ~$2,100/year all-in, breakeven is measured in single-digit customers. That's the quiet strategic advantage of lean: the platform can afford to wait for its market.