Bot Data Lost on Restart? Put SQLite on a Volume
Your bot's database disappears because container filesystems are thrown away on every redeploy. Mount a volume — and know exactly what triggers the reset.
SQLite or Postgres for Your Bot? One Question Decides It
Not scale — architecture. If one process owns the data, SQLite on a volume wins easily. If two apps need it, you have no choice, because volumes aren't shared.
You Probably Don't Need Redis — Caching for Small Apps and Bots
For a single small app, an in-process cache beats a Redis container on speed, cost, and security. Here's when that's true, and what to do when it isn't.
Nothing Backs Up Your Volumes — Here's How to Do It Yourself
A volume survives redeploys, not mistakes. There are no automatic backups, so here's a dump-and-ship routine that works, and the disk trap to avoid.
Self-Host Postgres Instead of Paying for a Managed Database Add-On
A managed Postgres add-on is often the biggest line on a small project's bill. Run Postgres as a container with a volume instead — and know the trade-offs.
File Uploads in a Container — `./uploads` Is Not a Place
Generated code saves uploads next to the app, where they vanish on deploy. Two real options, and the disk limit that stops every app when uploads grow.
Your AI-Built App Assumes One User — What Breaks With Two
Generated code keeps per-user state in module-level globals. One container means every visitor shares them, so the usual symptom is seeing someone else's data.
Your AI-Built App Assumes a Database That Isn't There
Models make one of three database assumptions, and all three break on a container platform. Fixing them takes minutes if you know which one you've got.
Run Background Work Inside Your Web App, Not Beside It
You don't need a second app for a scheduled job. One process with a background task is simpler — and here it's often the only option that shares your data.
Conversation Memory for an LLM Bot — Whose Context Is It?
Per-user or per-channel isn't a storage detail. It decides who sees whose messages, what each reply costs, and how fast your disk fills up.
Your Bot Greets Every Server Again on Every Restart
Guild Create fires in three cases and only one is a real join. Telling them apart needs storage that survives a deploy — which is why the bug exists.
Discord Attachment URLs Expire — Stop Storing Them in Your Database
CDN links are signed and time-limited, so a bot that saves them serves dead images later. Three fixes, and one that costs nothing at all.
Discord Buttons Stop Working After a Restart — Make Them Stateless
A button posted last month still renders and still fires. Your container doesn't remember it. Put the state in the custom_id, which gets you 100 characters.
When Your Disk Fills Up, Every App in Your Account Stops
Disk is the one resource you don't allocate — it's measured from what you actually wrote. Go over the account limit and nothing restarts until you're under it.
Does Anyone Actually Use My Bot? Counting It Properly
Logs rotate and memory resets on every deploy, so neither can answer it. Twenty lines and a table on a volume can — if you store rollups, not events.
Can You Do RAG on a Small Container? Yes, Within Limits
Calling an embedding API is cheap and fits fine. Running an embedding model doesn't — and rebuilding your index at startup means paying for it every deploy.
Adding Search to a Small App — SQLite FTS5, Not Elasticsearch
Full-text search ships inside SQLite. No second container, no network hop, no service to run — and on one container that's three structural problems avoided.
Self-Hosting Vaultwarden — It Fits Easily, and You Own the Backups
Vaultwarden runs comfortably in a small container. The hosting is the easy part — no snapshots exist, so losing the volume means losing the vault.
Storing User API Keys When Your AI App Lets People Bring Their Own
Environment variables hold your app's secrets, not your users'. Per-user keys need encrypted storage — and the first question is whether to store them at all.
Broadcasting to Your Telegram Bot's Users Without Getting Rate-Limited
Telegram caps bulk sends at about 30 messages a second and suggests spreading them over 8-12 hours. That makes a broadcast a resumable job, not a loop.
Linking a Telegram Account to Your App With Deep Links
The payload is 64 characters and visible to anyone with the link. Use a one-time token, not a user ID — and store it somewhere a redeploy can't erase.
You Deleted Your App — What Happens Next, and What You Can Do
Deleting is a soft delete with a retention window, but you can't undo it yourself. Here's what's recoverable, for how long, and how to not need it.
There's a File Browser in the Panel — Download a Backup Without a Shell
The Files tab browses your running container: download a database, upload a seed file, edit a config. Here's what persists and what quietly doesn't.
Move a Heroku App: Processes, Database, and Scheduled Jobs
Map Heroku processes and config vars to containers, then plan the changes needed for Postgres, Scheduler, files, and your app URL.
Protecting a Public Endpoint When There's No WAF or Rate Limiting
The edge terminates TLS and routes by hostname — that's all. Every other protection is your app's job. Here's the cheap 80% for a small service.
Build an RSS-to-Discord Feed Bot That Doesn't Spam Your Channel
A feed relay is three moving parts and one classic failure — reposting the whole feed after every redeploy. Here's how to build one that behaves.
Self-Host Uptime Kuma in One Form — Image, Volume, HTTPS
Deploy Uptime Kuma from its public Docker image with a persistent volume and an HTTPS URL, set in a single create form. Plus the one mistake to avoid.
A Stopped App Has No Shell — What You Can Still Do, and the Disk Catch-22
Shell and the file browser need a running container. Logs and events don't. Knowing which is which matters most when a disk overrun stops everything at once.