Most cloud marketing is written for a company you are not. It promises infinite scale, global regions, and hundreds of services, and it prices them for teams with a FinOps budget. If you are a solo technical founder with an MVP, ten beta users on the way, and a hard ceiling on what you can spend, "scales to millions" is not a feature. It is a warning that the bill can scale too.
This guide is a buyer's guide to cloud-based services for small business written from the other direction. Instead of asking "how big can this get?", it asks "can I know what I will pay, and will it stay up without me?" By the end, you will have a framework for comparing providers, a line-item budget for a production SaaS stack, and concrete tactics for keeping the whole thing under $40 a month.
What a small business actually needs from the cloud
Strip away the product catalog, and a typical small SaaS needs six things:
- Compute to run the web app, API, and maybe a background worker.
- A relational database with backups you have tested.
- Object storage for uploads, exports, and assets.
- A CDN so those assets load quickly wherever your users are.
- TLS and routing: HTTPS, custom domains, and a way to send traffic to healthy instances.
- A deploy pipeline from your repository or container registry.
Everything else (queues, search clusters, data warehouses, ML platforms) can wait until a customer pays for it. Every service you add before then is another bill and another thing that can break.
Three pricing models, three ways to get burned
Cloud-based services for small business fall into three pricing models. Each has a characteristic failure mode, and it is worth knowing them before you sign up.
Metered usage
You pay per vCPU-second, per GB of RAM per hour, per GB of egress. On paper, it is the fairest model: you pay for exactly what you use.
How it burns you: you pay for what your processes hold, not what they need. A memory leak in a Node process, a Python worker that loads a big library on import, or a database configured with generous buffers can double or triple a bill without any increase in traffic. Founders who have received a $180 invoice for an app with forty users usually learned this the hard way.
DIY virtual servers
A VPS has a fixed monthly price, and it is cheap. That part is real.
How it burns you: the price is fixed, but your time is not. You own OS updates, disk space, TLS renewals, backups, and restarts. The classic failure is Postgres running out of disk at night because Docker logs, old images, and write-ahead logs all grew on the same volume. A six-hour outage costs more than a year of the price difference.
Fixed plans with included usage
You pay a flat monthly fee that includes a defined amount of resources or usage credit, with the platform operating the infrastructure.
How it can burn you: if the plan limits are vague, or overages are expensive and uncapped, you are back to metered pricing with extra steps. The model only works if the provider tells you clearly what is included and what happens when you exceed it.
Predictability is not the same as cheapness. A plan that costs $39 every month is cheaper, in practice, than one that costs $12 most months and $180 once.
The questions to ask any provider
Before you commit, get a clear answer to each of these. If you cannot find it on the pricing page, that is an answer too.
- Can I state my monthly bill before I deploy? Not a calculator estimate. The actual number for the plan I am choosing.
- Is there a hard spending cap, or only alerts? Alerts tell you after the money is spent.
- Are database backups included, and can I restore without a support ticket?
- Is egress billed separately, and does traffic through the CDN count?
- How are team members priced? Your non-engineer co-founder needs to see whether the app is up without you paying for a full seat, or sharing your login.
- What does it cost to leave? Can I export my database with
pg_dumpand my files with the S3 API, or is my data in a proprietary format? - Who is on call when the host fails? If the answer is "you," it is not a managed service.
A $40 production budget, line by line
Here is a realistic budget for an MVP serving its first paying users. The point is not the exact numbers, which vary by provider and change over time. The point is that every line should be known before you deploy.
| Line item | What it covers | DIY across vendors | Unified platform |
|---|---|---|---|
| App hosting | Web + API containers | Separate PaaS or VPS | Included |
| Managed Postgres | Database with automated backups | Often the most expensive single line | Included |
| Object storage | Uploads and assets | Separate cloud account | Included |
| CDN | Cached delivery of assets | Separate CDN account | Included |
| TLS, domains | HTTPS certificates, routing | Your job on a VPS | Included |
| Backups off-site | Protection from disk failure | Your script, your bucket | Included |
| Vendors to manage | 3 to 5 | 1 |
When the stack is split across vendors, the total is the sum of several small bills, each of which can surprise you independently. When it is on one platform, it is one line.
Tactics that keep the bill under $40
Whatever provider you choose, these engineering habits keep resource use (and therefore cost) flat as traffic grows.
Cap your runtime's memory
Tell the runtime how much memory it has, so it collects garbage before it bloats. For Node:
ENV NODE_OPTIONS="--max-old-space-size=384"Set it to roughly 75% of the memory available to the container. For Python web servers, size workers deliberately instead of accepting defaults:
# 2 workers is usually enough for a small API; each worker is a full copy of your app in memory
gunicorn app.main:app -k uvicorn.workers.UvicornWorker --workers 2 --bind 0.0.0.0:8000The common 2 × CPU + 1 rule of thumb assumes you want to use the whole machine. On a small plan, fewer workers with async code is usually the better trade.
Pool database connections
Each Postgres connection costs server memory. A serverless-style app that opens a connection per request can exhaust a small database quickly. Use a pool with a hard ceiling:
from sqlalchemy import create_engine
engine = create_engine(
DATABASE_URL,
pool_size=5,
max_overflow=5,
pool_pre_ping=True,
pool_recycle=1800,
)With two API instances, that is at most 20 connections, which a small managed database handles comfortably.
Serve media from storage and CDN, not from your app
Every image your API streams is CPU, memory, and bandwidth billed at compute rates. Upload directly to S3-compatible storage with presigned URLs, and serve the files through the CDN. Your app only handles the metadata.
Compress before you store
Converting user uploads to WebP or AVIF on upload often cuts image size by half or more compared to the original JPEG or PNG. That reduces storage, CDN traffic, and page weight at the same time.
Do not run an always-on staging environment
A full copy of production running 24/7 doubles your compute for a service nobody uses at night. Deploy previews on demand and tear them down, or keep staging small.
Rotate logs and keep them short
Verbose debug logging in production costs you twice: once for disk or log retention, and once for the CPU spent formatting it. Log at INFO, and structure logs as JSON so you can search them without keeping everything forever.
Moving your Docker app without a rewrite
If your app already runs in Docker, moving it is mostly a matter of putting the image somewhere a platform can pull from. If you build on an Apple Silicon Mac, remember to build for the architecture your production host runs, which is usually linux/amd64:
echo "$GITHUB_TOKEN" | docker login ghcr.io -u your-username --password-stdin
docker buildx build \
--platform linux/amd64 \
-t ghcr.io/your-org/your-app:1.0.0 \
--push .Alternatively, skip the registry and connect the GitHub repository directly, so every push to main builds and deploys automatically. Either way, your Dockerfile stays the same. Configuration moves to environment variables, the database connection string comes from the managed database, and your upload code only needs a new S3 endpoint.
Where Granite.so fits
Granite.so is built for exactly this budget. You deploy from a GitHub repository or a Docker registry, attach a managed database with automated backups, and store files in S3-compatible storage served through a CDN, on a single plan with automatic scaling.
- Hobby: $9/month, including $15 of monthly usage credits. A good fit while you are onboarding your first beta users.
- Advanced: $39/month, with more room as you grow. This is the plan to pick if you want a production stack for your first paying customers and a total infrastructure bill that stays under $40.
Check the pricing page for the current details of each plan. The point is that you can write the number in your budget spreadsheet before you deploy, and show it to an investor without a footnote.
When $40 is not enough, and that is fine
Be honest with yourself about the edges of this approach:
- Heavy compute such as video transcoding, ML inference, or large data processing jobs will outgrow a small plan quickly. Price those workloads separately.
- Strict compliance requirements such as specific data residency, dedicated tenancy, or audit certifications may push you to a larger provider sooner.
- Growth is the good version of this problem. When you outgrow $40, you will have revenue to justify the next tier, and your standard Docker images, Postgres dumps, and S3 files move with you.
The short version
Cloud-based services for small business should be judged on predictability first and scale second. Pick a provider that tells you the price up front, runs your database and backups for you, and keeps app, storage, and CDN on one bill. Cap memory, pool connections, and push media to the CDN, and a production SaaS stack fits comfortably in $40 a month.
If that is the setup you want, Granite.so gets you there with your existing Docker workflow: connect the repo, attach a database, and get back to your first ten paying users.