How to Deploy a Docker App in Minutes

Most developers are comfortable building Docker images locally. You can write a Dockerfile, run docker build, and test your containerized application on your own machine without breaking a sweat. But when it comes time to actually deploy that container to a server where real users can access it, things get complicated fast.

Cloud platforms like Heroku, Render, and Railway make deployment easy — but that convenience comes at a steep price. You end up paying 3-10x what the underlying compute actually costs. For a simple app that needs 1 GB of RAM and a small database, you might be looking at $50-100/month on a managed PaaS, versus $5-10/month on a VPS.

Deployado gives you the best of both worlds: the portability and reproducibility of containers, with the simplicity of a managed platform. In this guide, we will walk through deploying a Docker app in minutes using Deployado — with infrastructure included.

Why Deployado for Docker?

Before we dive into the how, let's talk about why Deployado is a great choice for deploying Docker apps.

Predictable Pricing

Cloud PaaS providers charge a significant markup over raw compute costs. A $25/month Heroku dyno gives you less resources than what Deployado includes in its plan. When you multiply that across multiple services — your app, a database, a Redis instance, a background worker — the savings add up quickly. Teams running 3-5 services can easily save $200-500/month compared to traditional PaaS providers.

Infrastructure Included

With Deployado, you don't need to provision or manage servers. Infrastructure is included in your plan — servers, security, SSL certificates, and monitoring are all handled for you. Focus on building your app, not on managing infrastructure.

No Vendor Lock-in

Since your app is packaged as a standard Docker container, you can take it anywhere. Your Dockerfile and deployment configuration are portable. No proprietary buildpacks, no custom formats — just standard Docker. If you ever want to move, your app is ready.

Everything You Need, Built-in

Managed databases, auto-rollback, uptime monitoring, cron jobs, audit logging, and MCP/AI integration — all included out of the box. No add-ons to configure, no third-party services to stitch together.

Prerequisites

Before we get started, make sure you have the following:

• Your app with a Dockerfile — If your app doesn't have a Dockerfile yet, we will create one in the next section. Any language or framework works: Node.js, Python, Go, Ruby, Elixir, Rust, PHP — if it runs in Docker, it deploys with Deployado.
• A Deployado account — Sign up for free. You get a 14-day trial with full access to all features. No credit card required. Infrastructure is included in your plan.

Step 1 — Write Your Dockerfile

A well-written Dockerfile is the foundation of a reliable deployment. Here is an example multi-stage Dockerfile for a Node.js application that follows production best practices:

# Stage 1: Install dependencies
FROM node:20-alpine AS deps
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci --only=production

# Stage 2: Build the application
FROM node:20-alpine AS builder
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci
COPY . .
RUN npm run build

# Stage 3: Production image
FROM node:20-alpine AS runner
WORKDIR /app

# Create a non-root user
RUN addgroup --system --gid 1001 appgroup && \
    adduser --system --uid 1001 appuser

# Copy only what we need
COPY --from=deps /app/node_modules ./node_modules
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/package.json ./

# Switch to non-root user
USER appuser

EXPOSE 3000
CMD ["node", "dist/server.js"]

Let's break down the key best practices used here:

• Multi-stage builds — We use three stages to keep the final image small. Build tools, dev dependencies, and source code never make it into the production image. This can reduce your image size from 1 GB+ down to under 200 MB.
• Non-root user — Running as root inside a container is a security risk. We create a dedicated user with minimal permissions. If an attacker gains access to your container, they cannot escalate to root on the host system.
• npm ci instead of npm install — The npm ci command installs exact versions from package-lock.json, ensuring reproducible builds every time.

Don't forget to create a .dockerignore file to exclude unnecessary files from your Docker build context:

node_modules
.git
.env
*.md
.DS_Store
coverage
.nyc_output

Step 2 — Create Your Project

Once you have a Deployado account, create a new project from the dashboard. Deployado handles all the infrastructure for you — no servers to provision, no Docker to install, no agents to configure.

From your dashboard, create a project and connect your GitHub repository. Deployado will automatically:

• Build your Docker image from your Dockerfile
• Deploy the container to managed infrastructure
• Configure SSL certificates and a reverse proxy
• Set up health checks and monitoring

Your app's status, logs, and resource usage are all visible in real time from the dashboard.

Step 3 — Deploy Your App

With your server connected, you are ready to deploy. Deployado gives you two ways to get your app live.

Option A: Deploy with the CLI

The Deployado CLI gives you full control over your deployments from the terminal. First, install it:

npm install -g @deployado/cli

Then create your app and deploy:

# Create a new app
deployado apps:create my-app --port 3000

# Deploy the latest commit from your repo
deployado deploy my-app

# Watch the build logs in real time
deployado logs my-app --build

The CLI will clone your repository on the server, build the Docker image, and start the container. You will see the build output streamed to your terminal in real time.

Option B: Auto-deploy on Git Push

For a more automated workflow, enable auto-deploy. Every time you push to your configured branch (usually main), Deployado will automatically build and deploy your app:

# Enable auto-deploy for the main branch
deployado apps:update my-app --auto-deploy

# Now just push your code
git push origin main
# Deployado automatically detects the push and starts building

Your app will be available at my-app.deployado.com within minutes. Deployado automatically provisions an SSL certificate and configures a reverse proxy with Caddy.

Step 4 — Add a Database

Most applications need a database. Deployado provides managed PostgreSQL databases included in your plan — provisioned and configured automatically, with backups and monitoring built in.

# Create a managed PostgreSQL database
deployado databases:create my-app-db

# Connect it to your app
deployado databases:connect my-app-db my-app

# The DATABASE_URL environment variable is automatically
# injected into your app's container

When you connect a database to an app, Deployado automatically injects the DATABASE_URL environment variable into your container. Most frameworks (Rails, Django, Express, Phoenix) will pick this up automatically — no configuration changes needed.

Your database is provisioned with sensible defaults: daily automated backups, connection pooling, and monitoring out of the box.

Step 5 — Custom Domain & SSL

Your app is live on a .deployado.com subdomain, but you probably want to use your own domain. Adding a custom domain takes two steps:

1. Add a DNS record — Point your domain to your server's IP address. Create an A record for your root domain or a CNAME record for a subdomain.
2. Register the domain in Deployado:

# Add your custom domain
deployado domains:add my-app myapp.com

# Verify DNS configuration
deployado domains:verify my-app

Deployado automatically provisions a free SSL certificate via Let's Encrypt and configures HTTPS redirection. Certificate renewal is handled automatically — you never have to think about it again. Your users will see a green padlock from day one.

What's Next?

You now have a Docker app running with a database, custom domain, and SSL. Here are some next steps to make your deployment production-ready:

• Set up auto-rollback — Configure health checks so Deployado automatically rolls back to the previous version if a deployment fails. This prevents broken deploys from affecting your users.
• Configure uptime monitoring — Enable built-in uptime checks to get notified instantly when your app goes down, with automatic restart policies.
• Set up automated backups — Schedule daily database backups with configurable retention. Backups are stored securely in S3-compatible object storage and can be restored with a single command.
• Use the MCP server for AI-assisted management — Deployado includes an MCP (Model Context Protocol) server that lets AI assistants like Claude manage your infrastructure directly. Deploy apps, check logs, scale services, and troubleshoot issues through natural language conversations.