Deploy a FastAPI App With HTTPS — and Why It 502s if You Bind to localhost
Deploy FastAPI to a container with a free HTTPS certificate. Three things decide whether the URL answers, and getting them wrong still looks like a successful deploy.
Deploying a Node.js App — the Five Signals That Decide Your Build
Zero-config deploys aren't guesswork. Your lockfile, engines field, start script, build script, and port decide exactly what the build agent does.
Deploying a Vite + React SPA — The Fallback Rule and the Env Var Trap
A Vite build is static files, so two things break: refreshing a route 404s, and VITE_ variables are frozen at build time. Both have clean fixes.
Deploy a Go App — Static Binary, Tiny Image, Smallest Footprint You Can Run
Go compiles to one static binary, so it deploys as a scratch-based image with almost no runtime overhead. Use a Dockerfile, not the zip uploader.
Deploying a Rust API — The Runtime Is Tiny, the Build Is the Problem
A Rust binary is close to the perfect container workload. Getting one compiled inside a small build container is the part nobody warns you about.
Deploy From GitHub Actions With Git Push — No Vendor Action Needed
Deploy from a GitHub Actions workflow using plain git push to a deploy remote. No marketplace action, no OAuth app, no SSH keys — plus the shallow-clone trap.
Six Security Holes AI-Generated Apps Ship With — A Pre-Deploy Review
Models write for the happy path on a machine only you can reach. Once deployed, that code is your entire defence. Six things to check, each a two-minute grep.
Changing a Prompt in Production Without Breaking It
A prompt is the least protected code in your app — no type check, no test, and failures look like slightly worse answers. Version it and gate it on evals.
Deploying the Next.js App Your AI Built — Three Things That Will Bite
v0, Lovable and Bolt all output Next.js. The build is what fails first, and NEXT_PUBLIC_ variables set on the app never reach the browser. Here's why.
Deploying an AI-Generated Monorepo With a Frontend and a Backend
AI tools output frontend/ and backend/ folders, but the build only reads a Dockerfile at the root. Three ways to resolve that, and when one app beats two.
Deploying Phoenix on a Small Container — Single Node, and That's Fine
The BEAM is a great fit for a small container. The one thing you can't have is clustering, and most Phoenix apps don't miss it as much as you'd expect.
Deploying Rails With No Web Server in Front of It
Rails expects nginx to exist and a master key to be on disk. Neither is true in a container here, and both failures look nothing like their cause.
Tell Your AI How It'll Be Deployed — One Prompt Block, Nine Fewer Bugs
Models write for localhost because that's the only target they're given. Paste these constraints into your prompt and most deploy-day failures never happen.
How Do You Know Your Prompt Change Made Things Better?
You can't tell from one example. A file of test cases and a script catches regressions — and it belongs in CI, not on the container you're paying for.
Your Users Get Logged Out Every Time You Deploy
Two causes, both common in generated auth code — sessions kept in memory, or a signing secret regenerated at startup. Neither looks like a bug locally.
Move an App From Railway: Services, Networking, and Data
Move a Railway service to JustRunMy.App. Check private networking, reference variables, Railpack builds, cron jobs and replicas before switching traffic.
One Smoke Test Beats a Test Suite You'll Never Write
AI tools write features, not tests. You don't need coverage — you need one check that boots the app the way the container will and proves it answers.
Installing Private Dependencies When Your Build Has No Secrets
No build args, no registry credentials, no BuildKit secret mounts. Three ways to get a private package into your image, and the one that actually scales.
Push to `build` to Test a Build Without Touching Your Running App
Two branches are tracked, not one. `deploy` builds and replaces your container; `build` only builds — which is what you want while you're still iterating.
Self-Host Gitea — The Deploy Remote Isn't a Code Host
The built-in git remote is push-only and exists to build your app. If you want somewhere to actually keep repositories, run your own Gitea in one container.
Turning a Python Script Into a 24/7 Paid Service
A script that runs once and exits isn't a hosting problem, it's a shape problem. Five changes turn it into a worker that survives restarts and says what it did.
Your Agent Says It Deployed — Four Checks Before You Believe It
"Deployed successfully" means the API calls returned, not that your app works. The status is container-level, so it can be green while nothing works.
Every Redeploy Drops Every WebSocket — Designing Realtime Apps for It
There's no connection draining and about a second between stop and kill. So plan for the reconnect — and for every client reconnecting at the same instant.
Your AI Wrote a Dockerfile — Check These Nine Things Before You Push
LLM-written Dockerfiles are usually valid and frequently wrong in the same ways. Three break the build, three deploy fine and then don't work.
Built on an Apple Silicon Mac? Your arm64 Image Won't Deploy
The platform runs linux/amd64. An arm64 image doesn't fail loudly — the tag never shows up and auto-deploy quietly skips it. Build with --platform.
Your Bot Posts at the Wrong Time — Containers Run on UTC
The clock is right; the timezone isn't. Why TZ fixes less than you think for a scheduled bot, and what to do instead so October doesn't break it.
Your Bot Token Is in Your Git History — Rotate It, Don't Scrub It
Once a token has been pushed anywhere, it's burned. Regenerate it, move it to an environment variable, and stop shipping secrets inside the image.
Your Build Gets Less Memory Than Your App — Why Bundles Fail to Compile
Builds run in their own capped container, so raising your app's RAM doesn't help. Here's what blows the limit and the four ways around it.
Building a Bot With Someone Else — Collaborate in the Repo, Not the Panel
Apps have a single owner, so there's no way to share one. That's less limiting than it sounds if deploys run from CI, and it forces a better setup anyway.
Config Files vs Environment Variables — When Your App Needs a Real File
Env vars cover most settings, but some software only reads a file. Here's how config-file mounts work, and the rules that reject your input if you break them.
Deploying an App You Built With an AI Coding Tool — A Checklist
AI-generated projects run fine locally and break in six predictable ways when deployed. Here's what to fix before you upload, and what you can leave alone.
Deploy a .NET App on a Small Container — Publish First, Then Tune the GC
.NET runs fine on a modest container if you upload publish output rather than source, and know the two GC settings that decide its memory footprint.
Deploy With Git Push Without GitHub — No OAuth Connection Needed
Deploy with git push without GitHub, GitLab, or an OAuth connection. Push a local repo straight to a deploy remote, watch the build stream back, done.
Deploying a Python Bot — What the Build Agent Decides for You
Python version, Poetry vs pip, legacy aiogram pins, and unbuffered logs are all inferred from your project. Here's what gets chosen and how to influence it.
Deploy Without a Dockerfile: AI Build Agent vs. Buildpacks
You can deploy without a Dockerfile using buildpacks or an AI build agent. Here's how the two differ, where zero-config detection fails, and which to pick.
Your Docker Image Is 1.2 GB — Here It Costs Downtime, Not Storage
Image size doesn't count against your disk quota; volumes do. So slim images for a different reason — every redeploy pulls the thing before your app starts.
Hosting a Webhook Receiver — 10 Seconds, a Signature, and a Redeploy
A webhook endpoint needs public HTTPS, a fast 2XX, and a verified signature. Here's how to build one that doesn't lose events when you redeploy.
Host a Discord Bot Without an HTTP Server
Deploy a Discord gateway bot as a worker with a ZIP, set its token as an environment variable, and check logs and data before leaving it running.
How to Roll Back a Bad Deploy — and What Won't Roll Back With It
Pushed images keep a tag history you can switch back to in one click. But your database migration doesn't roll back, and `latest` destroys the option entirely.
Running a Java or Kotlin Discord Bot (JDA) on a Small Container
Java bots deploy via Dockerfile, not the zip flow. The work is telling the JVM how much of the container it may use — and getting the build to fit.
Deploying Laravel on a Single-Process Container With FrankenPHP
The classic PHP stack is two processes. A container platform wants one. FrankenPHP collapses nginx and PHP-FPM into a single binary — here's the setup.
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.
Add a One-Click Deploy Link to Your Project's README
Turn any public Docker image into a shareable deploy link with the image, volumes, ports, and env vars pre-filled. Just a URL — no manifest file to maintain.
Private Docker Registry Hosting Without Docker Hub Rate Limits
Get a private Docker registry with its own credentials, push images straight to it, and run them — no Docker Hub pull limits and no public image listings.
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.
Run Scheduled Tasks Without a Cron Service
If your bot or worker runs continuously, put the schedule inside it rather than paying for a separate cron service.
Self-Host ntfy for Push Notifications From Your Bots and Scripts
One small Go binary turns any curl command into a phone notification. Here's the deploy, the auth config people skip, and the honest iOS caveat.
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.
You Get a Shell in Every Container — Even a Distroless One
Minimal images normally mean no shell and no debugging. A static busybox is mounted into every container here, so scratch images stay inspectable.
Run a Staging Bot Alongside Your Live One Without Doubling the Bill
Test bot changes on a second bot account instead of in production. Two apps, two tokens, one codebase — and the app count doesn't affect what you pay.
Telegram Bot Hosting: Polling vs Webhook, and What Each One Needs
Polling needs no ports and no domain. Webhooks need HTTPS on port 443 with a valid certificate. Here's how to pick, and how to run either one.
What Happens When You Redeploy — and Why You Get One Second to Shut Down
A redeploy stops your container, removes it, and builds a new one. Nothing overlaps, so there's real downtime — and your shutdown window is about a second.
Which Deploy Path Should You Use? A Five-Way Decision Guide
Zip upload, git push, Docker push, prefab template, or existing image — each has a real constraint. Here's how to pick in about thirty seconds.
"It Works Locally" — Why Your Bot Breaks the Moment You Deploy
Same code, different machine. Case-sensitive filenames, CRLF line endings, a UTC clock, and missing env vars cause most of it. Here's the checklist.
Deploy Apps From Your AI Coding Agent via MCP (Cursor, VS Code, Claude Code)
Connect Cursor, VS Code, or Claude Code to JustRunMy.App's MCP server and deploy, configure, and operate apps directly from your AI agent.
Deploy an MQTT Broker with Docker: Eclipse Mosquitto on a Raw TCP Port
How to deploy Eclipse Mosquitto as a public MQTT broker using a Docker image, a mounted config file, a persistent volume, and a raw TCP port.