Tutorial11 min read
Vue 3 SPA: From git push to Production URL
Deploy a Vue 3 single-page app to a global CDN in under 90 seconds—automatic build detection, environment variable injection, and one-command redeploys.
2026-08-04Read more
Step-by-step deployment guides for every major language and framework on PandaStack.
400 articles
Deploy a Vue 3 single-page app to a global CDN in under 90 seconds—automatic build detection, environment variable injection, and one-command redeploys.
Deploy a Preact app with an Express backend that stores user sessions in PandaStack's managed Redis. KV_URL auto-injection, HTTP REST fallback, and why redis-cli doesn't work.
Deploy a Solid.js SPA with a config file that prompts for API URLs and keys at deploy time. No hardcoded secrets, no manual setup, just a form that enforces what's required.
Add a deploy button to your Vite+React repo that auto-detects build settings and puts your SPA on a CDN in under two minutes, no dashboard required.
Stop hardcoding API keys in your Vite app. Use pandastack.json to prompt for secrets during deploy, so every environment gets its own config without exposing credentials.
You added a custom domain to your Vue 3 app, but browsers show an SSL warning. The fix: wait for DNS propagation, verify CNAME records, and force a certificate refresh.
Deploy a Preact static site using the panda CLI, configure custom domains and SSL, roll back bad releases, and monitor traffic with zero client-side analytics SDK.
Run request validation, rate limiting, and auth checks in a Python edge function with sub-50ms response times, no container overhead, and pay-per-invocation pricing.
Add a deploy button to your SolidJS starter repo so users can launch a live demo in under a minute, with environment prompts and automatic build detection.
Point a custom domain at a SvelteKit static export deployed on PandaStack, provision an automatic SSL certificate, debug DNS propagation, and handle www vs apex domain routing.
Deploy a Vite + React app, push a broken build to production, and roll back to the last working version using the PandaStack CLI or API with zero downtime.
Deploy a Hono API using the panda CLI and a config file that prompts for environment variables. Port binding, health checks, and live logs in under ten minutes.
Deploy a Hono API backed by a managed PostgreSQL database—automatic DATABASE_URL injection, connection pooling, and zero-config SSL on PandaStack.
Deploy a single service from a monorepo by setting rootDir to apps/api—PandaStack runs the build in that directory and ignores the rest of the repo.
Deploy a scheduled Node.js script that deletes expired database rows every night. Cron syntax, DATABASE_URL injection, execution logs, and how to test a cronjob without waiting 24 hours.
Ship a Nuxt static site in three ways — REST API from CI, a one-click deploy button, and the dashboard. Zero server runtime, full CDN caching, instant cache purges on redeploy.
The build succeeds, the pod starts, but requests time out—how to debug port binding, health checks, and process management in containerized apps.
Point PandaStack at apps/web in your monorepo and deploy just that service. The rootDir field in pandastack.json makes the build context shallow, skipping unrelated packages.
Add a Redis-backed cache to your NestJS API using PandaStack's managed KV store. Automatic KV_URL injection, ioredis client setup, and cache invalidation patterns.
Deploy Next.js as a static site with a one-click README button. No Node.js server needed, just pre-rendered HTML served from a CDN with sub-second load times.
Build and deploy just the apps/marketing folder of a monorepo, pointing PandaStack at the subdirectory with rootDir so the build runs in the right context and finds the lock file.
Deploy a Go Fiber API with environment variables that prompt for values on deploy. Use pandastack.json to prevent missing config and the panda CLI for instant redeploys.
Automate Astro documentation site deploys from GitHub Actions. Use the REST API with a psk_ token to trigger builds on every push, with zero manual clicks.
Run a nightly PostgreSQL cleanup task that deletes expired records. Cronjob scheduling with cron syntax, DATABASE_URL injection, and logging for audit trails.
Deploy a serverless Node.js function that handles API requests without a full Express app. Sub-second cold starts, automatic scaling, and pay-per-invoke pricing.
Connect Express to a managed MySQL instance with automatic DATABASE_URL injection, connection pooling, and proper error handling for production traffic.
Run Flask in production with Gunicorn as the WSGI server, connected to a managed Postgres database. Migrations via Alembic, connection pooling, and proper bind address config.
Deploy Angular apps in continuous integration using the PandaStack API with bearer tokens, environment variables injected at build time, and secret rotation without re-pushing code.
Run a Node.js script every morning at 9 AM to query a database for pending notifications and send emails via SendGrid, with cron syntax, failure retries, and execution logs.
Deploy a Fastify API on PandaStack with a managed Redis instance for session storage and response caching, using KV_URL for native clients and KV_REST_API for HTTP-based access.
Deploy a Go Gin REST API on PandaStack with a managed PostgreSQL 16 instance, automatic DATABASE_URL injection, connection pooling via pgx, and database migrations on startup.
Speed up Astro static site builds by 60% with dependency caching—how PandaStack's build cache works and how to verify it's active.
Ship an Astro static site with a README button for instant clones, GitHub Actions for auto-deploys, and CDN edge caching with instant purges on every push.
Deploy a Django app with a managed Postgres backend, custom build commands that run collectstatic and migrations, and Gunicorn bound to the right port. Zero-downtime deploys included.
Build a rate-limiting edge function with Node.js runtime that blocks abusive clients before they hit your backend. In-memory tracking, HTTP invocation, and sub-100ms responses.
Stop deploying apps with missing configuration—use the env array in pandastack.json to prompt users for API keys and secrets before the build starts.
Deploy FastAPI from GitHub Actions using the PandaStack REST API. Token-based auth, automated redeploys on merge, and build status webhooks for Slack notifications.
Wire a managed Redis KV store to your FastAPI app for caching and session storage—automatic KV_URL injection, HTTP REST API access, and zero-config TLS.
Deploy apps/api from a monorepo without extracting it to a separate repo. The rootDir field, workspace dependencies, and build context isolation in one walkthrough.
Use the PandaStack REST API in your GitHub Actions workflow to trigger deployments on every push, with build logs and deployment status checks built in.
Deploy a Go Fiber API with a managed MySQL database wired in automatically. DATABASE_URL injection, migration scripts, connection pooling, and zero-config SSL.
A complete, practical guide to deploying a production-ready Bun and Hono API on PandaStack. Covers build configuration, database migrations, environment variables, and going live via Git push.
A complete, step-by-step tutorial for deploying a production-ready Deno Oak API with a managed PostgreSQL database to PandaStack using a Git-push workflow.
SurrealDB is a multi-model database that speaks SQL-ish, graph, and document all at once. Here's how to run a persistent, production SurrealDB instance on PandaStack with a real backing volume — not the in-memory demo everyone accidentally ships.
ClickHouse ingests billions of rows and answers analytical queries in milliseconds — if you set it up right. Here's how to run a persistent, secured ClickHouse instance on PandaStack, wire it to your app, and avoid the config traps that make it slow.
Valkey is the Linux Foundation's open-source fork of Redis 7.2, created after Redis changed its license in 2024. Here's how to run a self-hosted Valkey cache on PandaStack, when to use it over managed Redis, and how to connect from your app.
Django Ninja gives you FastAPI-style typed, async, auto-documented endpoints on top of Django's ORM, admin, and auth. Here's how to containerize one and deploy it to PandaStack with managed PostgreSQL.
Robyn is a Python web framework with a multi-threaded Rust runtime — Flask-like ergonomics, serious throughput. Here's how to containerize and deploy a Robyn API to PandaStack with PostgreSQL.
Starlight is Astro's official docs framework — fast, searchable, dark-mode-ready, and fully static. Here's how to build a documentation site with it and deploy it to PandaStack's static hosting with automatic SSL and Git-push deploys.
Dagster is an asset-oriented orchestrator that makes data pipelines observable and testable. Here's how to run the Dagster webserver and daemon on PandaStack with a PostgreSQL-backed run store and scheduled materializations.
MLflow tracks your ML experiments, parameters, metrics, and model artifacts in one place. Here's how to run a persistent MLflow tracking server on PandaStack backed by managed PostgreSQL and object storage.
Dify is an open-source platform for building LLM apps — RAG pipelines, agents, and chat assistants with a visual builder. Here's how to self-host it on PandaStack with managed PostgreSQL, Redis, and a vector store.
Novu is open-source notification infrastructure — one API for email, SMS, push, and in-app notifications with a template editor and user preferences. Here's how to self-host it on PandaStack with and Redis.
Unleash is an open-source feature-flag platform with gradual rollouts, targeting, and kill switches. Here's how to self-host the Unleash server on PandaStack with managed PostgreSQL and wire up an SDK.
Hoppscotch is a fast, open-source API client — a self-hostable alternative to Postman with team collections and environments. Here's how to run it on PandaStack with managed PostgreSQL for your whole team.
Your Expo app ships to the App Store, but the API, database, and over-the-air update server live somewhere. Here's how to stand up a production React Native backend on PandaStack in an afternoon.
Flutter isn't just for phones — `flutter build web` gives you a static bundle you can host anywhere. Here's how to deploy it on PandaStack with correct routing, caching, and a CanvasKit vs HTML renderer decision.
Hydrogen is Shopify's React storefront framework, and it's built on Remix — which means you can run it as a normal Node server anywhere, not only on Oxygen. Here's how to containerize and deploy one on PandaStack.
Effect is the TypeScript library that finally makes typed errors, dependency injection, and structured concurrency ergonomic. Here's how to package an Effect HTTP API into a container and ship it on PandaStack.
Vike is the framework-agnostic SSR layer on top of Vite — bring your own React, Vue, or Solid. Here's how to deploy a Vike app on PandaStack in both SSR (container) and pre-rendered (static) modes.
Inngest gives you durable, event-driven background jobs with retries and step functions — and it can be self-hosted. Here's how to run the Inngest server plus your functions on PandaStack.
Trigger.dev is an open-source background-jobs framework with long-running tasks, retries, and no timeouts. Here's how to run your Trigger.dev tasks and the app that triggers them on PandaStack.
dbt turns raw warehouse tables into clean, tested models — but something has to run `dbt build` on a schedule. Here's how to containerize a dbt project and run it as a PandaStack cronjob against Postgres.
vLLM is the high-throughput inference engine behind a lot of self-hosted LLM setups, with an OpenAI-compatible API. Here's how to containerize it and deploy it on PandaStack — plus an honest note about GPUs.
LiteLLM gives you one OpenAI-compatible endpoint in front of 100+ LLM providers, with keys, rate limits, and cost tracking. Here's how to run the LiteLLM proxy on PandaStack with Postgres and Redis.
CrewAI orchestrates multiple AI agents into a 'crew' that collaborates on a task. Here's how to wrap a crew in a FastAPI endpoint and deploy it on PandaStack — with the async pattern that keeps it from timing out.
Genkit is Google's open-source framework for building AI features with flows, structured output, and observability. It's just a Node server underneath — here's how to containerize a Genkit app and deploy it on PandaStack.
Gleam is a friendly, type-safe language on the Erlang BEAM, and Wisp is its web framework. Here's how to build a Gleam web app into a release and deploy it as a container on PandaStack.
Ship a Rocket 0.5 app to production: release builds, the three config gotchas, sqlx migrations, a caching Dockerfile, and a managed Postgres wired in.
Run a Scrapy spider on a schedule, write items straight to managed PostgreSQL via DATABASE_URL, and deploy the whole thing with a git push.
Ship a SolidStart app: the node-server preset, the self-contained .output build, VITE_ env var rules, and Drizzle migrations done safely.
Ship a Starlette app properly: ASGI server setup, async SQLAlchemy, Alembic migrations, and a managed Postgres wired in via DATABASE_URL.
Ship Strapi 5 to production: Postgres config, the five required secrets, the uploads gotcha, and git-push deploys with DATABASE_URL auto-wired.
Streamlit's rerun model changes how you deploy it: server config, WebSockets, cached DB connections, and going live via git push.
Run the core of Supabase yourself: managed Postgres, PostgREST, and GoTrue auth as three small services glued together by one JWT secret.
Deploy SvelteKit with adapter-node: the ORIGIN gotcha, runtime vs build-time env vars, Drizzle migrations, and going live with a Git push.
Deploy a Symfony app with managed PostgreSQL: production build flags, Doctrine migrations, a FrankenPHP Dockerfile, and going live on Git push.
Deploy a standalone tRPC server: adapter choice, tsup build, the monorepo type-sharing gotcha, Drizzle migrations on DATABASE_URL, and going live via Git.
Self-host Umami with a managed PostgreSQL database: the Docker image route, the build-from-source gotchas, migrations, and the tracking script.
Ship a Vapor 4 app to production: release builds, the 127.0.0.1 trap, Fluent migrations, DATABASE_URL wiring, and a Dockerfile that works.
Build a production vector search API with FastAPI and pgvector, then ship it with a managed Postgres wired in via DATABASE_URL — schema, index, Dockerfile included.
Deploy Vendure to production: build the server and worker, run TypeORM migrations safely, fix the asset storage trap, and wire up PostgreSQL via DATABASE_URL.
Ship a VitePress docs site: the real build output directory, dead-link failures, clean URLs, local search, and git-push deploys with automatic SSL.
Ship a LangChain FastAPI service for real: pinned dependencies, SSE streaming, Postgres-backed chat history, a proper Dockerfile, and going live via Git push.
A practical Laravel deploy guide: the config:cache trap in containers, a FrankenPHP Dockerfile, DB_URL vs DATABASE_URL, and safe production migrations.
Take a Litestar app to production: Uvicorn workers, the asyncpg DATABASE_URL scheme gotcha, Alembic migrations, and git-push deploys.
Ship a LlamaIndex RAG API as a FastAPI service: store vectors in Postgres, split ingestion from serving, and go live with a Git push.
Build Medusa for production, run migrations safely, wire up PostgreSQL and Redis, and go live from a Git push — including the .medusa/server gotcha.
Deploy Metabase for real: kill the H2 default, wire the app database to managed Postgres, set the encryption key, and ship it with a Git push.
Build the shadow JAR, map DATABASE_URL to Micronaut's datasource config, run Flyway migrations, and go live with a Git push.
Run n8n in production: Postgres instead of SQLite, a stable encryption key, correct webhook URLs, and a Git-push deploy that survives restarts.
Build NestJS for production, wire TypeORM to a managed Postgres via DATABASE_URL, run migrations safely, and ship it with a git push.
Deploy a Nuxt 3 app to production: the .output build, Nitro port/host config, NUXT_ runtime env vars, Prisma migrations, and going live via Git push.
Run your own Ollama endpoint on CPU: bake a quantized model into the image, size RAM honestly, lock down the unauthenticated API, ship via Git.
Deploy Phoenix the right way: mix releases, the generated Dockerfile, migrations without Mix, LiveView origin checks, and Postgres via DATABASE_URL.
Self-host Plausible Community Edition: the two-database architecture, managed Postgres via DATABASE_URL, ClickHouse options, and migrate-on-start.
Turn a Postgres schema into a production REST API: roles, config, migrations, health checks, pool sizing, and git-push deploys.
Build the fast-jar, convert DATABASE_URL into JDBC config, run Flyway on boot, and ship a Quarkus app to production via Git push.
Deploy a Qwik City app for real: pick the right adapter, build the server bundle, handle env vars Qwik's way, and wire in managed Postgres.
Deploy a Rails 7 app end to end: precompile assets without leaking your master key, a production Dockerfile, safe migrations, and DATABASE_URL wiring.
Build RedwoodJS for production, switch Prisma to Postgres, run migrations safely, and ship the whole app — web and API — as one container via Git push.
Reflex compiles to a static frontend plus a WebSocket backend. How to ship both behind one port, run Alembic migrations, and wire managed Postgres.
Deploy Remix to production: the Vite build, remix-serve and PORT, Prisma migrations, a working Dockerfile, and a managed Postgres wired in via DATABASE_URL.
Take an Axum service to production: correct listener setup, a distroless Dockerfile, embedded sqlx migrations, and graceful shutdown that actually fires.
Ship a Chainlit chat app for real users: headless mode, WebSocket gotchas, persistent chat history on Postgres, and going live with a Git push.
Run Directus in production: bootstrap the database, map DATABASE_URL, handle file storage and schema migrations, and deploy via Git push.
Take Django from runserver to production: gunicorn, WhiteNoise static files, dj-database-url, safe migrations, and a Git-push deploy with managed Postgres.
Dramatiq workers have no port, no HTTP, and no forgiveness for bad connection math. Broker setup, Dockerfile, and the scale-to-zero trap.
Deploy an Elysia API to production: correct port binding, a lean Bun Dockerfile, Drizzle migrations, and managed Postgres wired in via DATABASE_URL.
Take an Express app to production: port and proxy config, pg connection pooling, node-pg-migrate migrations, a clean Dockerfile, and going live via Git push.
Deploy a FastAPI app with a managed Postgres database: production server setup, Alembic migrations, DATABASE_URL wiring, and going live via Git push.
The 0.0.0.0 binding gotcha, pino logs done right, graceful shutdown, node-pg-migrate with DATABASE_URL, and a lean production Dockerfile.
Ship a Flask app to production the right way: Gunicorn, a managed PostgreSQL wired in via DATABASE_URL, Alembic migrations, and deploys on git push.
Deploy a Fresh (Deno) app to production: ahead-of-time builds, a working Dockerfile, Postgres over DATABASE_URL, and going live with a git push.
Self-host Ghost properly: the official Docker image, MySQL 8 wired via DATABASE_URL, the url config trap, image storage, and SMTP — end to end.
Take a Gin app from dev defaults to production: release mode, trusted proxies, graceful shutdown, goose migrations, and Postgres via DATABASE_URL.
Ship an Echo app as a static binary: PORT handling, a distroless Dockerfile, embedded migrations, and managed Postgres wired in via DATABASE_URL.
Take a Fiber app to production: a 15 MB distroless image, pgx against managed Postgres, golang-migrate as a release step, and the prefork trap.
Move a Gradio app off share=True and into production: server binding, queue tuning, model loading, and logging predictions to Postgres.
Run your own Hasura GraphQL Engine: migrations and metadata as code, a production Dockerfile, the env vars that matter, and go-live via git push.
Deploy Hono as a long-lived Node server: the node-server adapter, PORT and 0.0.0.0 binding, Drizzle migrations, and going live via Git push.
Deploy Keystone 6 to production: build the Admin UI, run Prisma migrations safely, wire up DATABASE_URL, and ship via Git push.
Build a Ktor fat JAR, parse DATABASE_URL into HikariCP, run Flyway migrations safely, and ship the whole thing with a Git push.
Ship an Actix Web app to production: release builds, a cached Dockerfile, sqlx migrations against managed Postgres, and going live with a git push.
Deploy an AdonisJS 6 app to production: the build step, APP_KEY and env validation, Lucid migrations, DATABASE_URL wiring, and going live on a Git push.
Self-host Appsmith the right way: externalize and Redis, set encryption keys, wire a managed Postgres datasource, and ship via Git push.
Deploy Astro the right way: static build to dist/, SSR with the Node adapter, PUBLIC_ env var rules, and a managed Postgres wired in via DATABASE_URL.
Single sign-on centralizes identity, kills password sprawl, and makes offboarding instant. This tutorial walks through SAML and OIDC setup, common pitfalls, and how to roll SSO out without locking yourself out.
Old sessions, expired tokens, soft-deleted rows, stale logs — they pile up. Here's how to write and schedule a safe database cleanup cronjob that won't lock your tables.
Auto-detection covers the common case, but real apps need custom build and start commands. Here's how to override both correctly, with patterns for Node, Python, Go, and Docker.
A step-by-step migration guide from Firebase Hosting, Functions, and Firestore to PandaStack's container apps, edge functions, and managed databases — including the data-model decisions you'll need to make.
Windmill turns scripts in Python, TypeScript, Go, and Bash into APIs, schedules, and UIs. Here's how to self-host its server plus worker architecture on top of Postgres.
Typesense is an open-source, typo-tolerant search engine built for speed. Learn how to deploy it to production with a secure API key, persistent data, and scoped search keys for the browser.
Deploy a Svelte single-page application to production: the Vite build, SPA fallback routing, environment variables at build time, custom domains with SSL, and continuous deploys from Git.
Deploy an application backed by a vector database: choosing pgvector versus a dedicated vector store, schema and indexing, embedding generation, similarity queries, and wiring it all together in production.
Cron expressions look cryptic but follow simple rules. This tutorial breaks down all five fields, the special characters, common real-world schedules, and the timezone and overlap gotchas that trip people up.
GitLab CI/CD is a powerful, YAML-driven pipeline engine. This tutorial walks through building a real deploy pipeline, stages, jobs, caching, environments, secrets, and connecting it to a deployment target.
TinaCMS edits Markdown stored in your Git repo, giving you a visual editor without a database. Here's how the Git backend works, how to self-host Tina, and how to deploy editor plus site together.
Point your own domain at a static site with proper DNS, automatic SSL, and a working apex + www setup. A step-by-step guide that explains the DNS records, not just the clicks.
npm, yarn, pnpm, or bun — switching package managers in a deploy is mostly about the lockfile and the install command. Here's how to do it cleanly without breaking CI.
Migrate your Fly.io apps from fly.toml and Dockerfiles to PandaStack: translating config, moving Postgres data, handling volumes and secrets, and the architectural differences to plan around.
A complete guide to deploying a Symfony application to production with a managed PostgreSQL database, covering Dockerfile setup, Doctrine migrations, environment configuration, and zero-downtime releases.
Wasp is a declarative full-stack framework that generates a React client and Node/Express server from a single config. Learn how to deploy a Wasp app to production with PostgreSQL.
SvelteKit's adapters decide everything about how you deploy. Learn when to use adapter-node vs adapter-static, how to containerize the Node build, and how to ship it to production.
Deploy a Streamlit data app to the cloud: configure the server for containers, handle WebSockets and session state, cache expensive work, and ship with one Git push.
RabbitMQ is the battle-tested message broker behind countless async architectures. Learn how to deploy it with durable storage, a secure default user, and the management UI enabled.
Axum is the ergonomic, Tokio-based web framework taking over Rust backends. Learn how to build a lean multi-stage container image and deploy an Axum API to production with a managed database.
Vendure is a TypeScript/Node headless commerce framework. Learn how to deploy its server and worker processes with PostgreSQL and persistent asset storage on a managed cloud.
Headless WordPress keeps the editor everyone loves while serving content through an API to a modern frontend. This tutorial covers the architecture, REST vs WPGraphQL, and deploying the pieces with a managed database.
Deploy a Spring Boot service with an auto-wired managed Postgres: layered or buildpack images, HikariCP pool tuning, Flyway migrations, actuator health checks, and graceful shutdown.
Daily digests, weekly reports, trial-expiry reminders — all driven by a cronjob. Here's how to build a reliable scheduled email job that's idempotent and won't double-send.
Get a Slack message every time you deploy — who, what, and whether it succeeded. Here's how to wire deploy notifications with incoming webhooks and rich Block Kit messages.
Move your Netlify static sites, redirects, environment variables, and serverless functions to PandaStack — with a clear mapping of Netlify features to their PandaStack equivalents and the gotchas to watch for.
A practical guide to streaming, reading, and searching live build logs so you can debug failing deploys fast — what to look for, how log streaming works, and the patterns that catch most build errors.
RedwoodJS splits into an API side and a web side, each with its own build output. This guide covers building both, running Prisma migrations, and deploying the GraphQL API plus the static frontend correctly.
Sinatra is the minimal Ruby web framework. Here's how to take a single-file app to a production-grade container with Puma, proper port binding, and a clean Dockerfile.
Tornado is a battle-tested async Python framework built for long-lived connections and WebSockets. Here's how to deploy it to production with the right process model and a clean container.
TanStack Start is a full-stack React framework with type-safe server functions, SSR, and streaming, powered by Vite and Nitro. Learn how to deploy it to production as a Node server.
Deploy Typesense, the open-source typo-tolerant search engine: container setup with persistent data, the API key model, defining a collection schema, and notes on running a high-availability cluster.
Self-host Weaviate with persistent storage and API-key auth, choose between bring-your-own vectors and built-in vectorizers, and tune your schema for production search.
Deploy Phoenix to the cloud with Elixir releases, a multi-stage Docker build, runtime config, Ecto migrations, and the clustering and LiveView considerations that production demands.
Remix runs everywhere there's a request/response — but production still needs a real server, a managed database, and migrations. Here's a clean Docker + PostgreSQL deployment with Prisma.
Deploy a Telegram bot to the cloud: choose long polling vs webhooks, secure your token, persist state, and run it reliably — with the right setup for each model.
A guide to deploying multiple services from a single monorepo — root directories, build context, shared packages, selective rebuilds, and keeping a web app, API, and worker in sync.
How to handle environment variables cleanly across local, staging, and production — separating config from secrets, avoiding the .env-in-git disaster, and keeping environments in sync.
tRPC gives you end-to-end type safety with no codegen, but deploying it means thinking about how client and server ship together. This tutorial covers monorepo and Next.js setups, plus the database wiring.
Saleor is a GraphQL-first, headless commerce platform built on Django. Here's how to self-host the Saleor core API with PostgreSQL, Redis, and a Celery worker on a modern cloud platform.
Umami is a simple, fast, privacy-focused analytics tool that runs on a single PostgreSQL database. Here's how to self-host it end to end with auto-wired database credentials.
Deploy a Python RQ (Redis Queue) background worker to production: separating the worker process from your web app, connecting managed Redis, handling retries and timeouts, and scaling worker concurrency.
Deploy a retrieval-augmented generation chatbot to production: the ingestion and query architecture, wiring a vector store, managing embeddings, streaming responses, secrets handling, and scaling the moving parts.
Deploy a Slack bot to production: choosing between Socket Mode and HTTP events, handling Slack's 3-second response deadline, securing signing secrets, and going from local development to a live, always-on bot.
A realistic guide to deploying a Stable Diffusion inference API: GPU vs CPU tradeoffs, model loading and caching, request queuing for expensive jobs, memory management, and packaging the service in a container.
Deploy an Eclipse Vert.x reactive application to production: building a fat JAR, tuning the event loop for containers, handling backpressure, health checks, and connecting a managed database with the reactive Postgres client.
Deploy a production WebSocket server: ingress and upgrade handling, heartbeats and idle timeouts, horizontal scaling with a pub/sub backplane, graceful shutdown, and connection limits.
Streamlit turns Python scripts into interactive data apps, but it runs a stateful WebSocket server that needs the right deployment setup. This guide containerizes Streamlit and connects it to a database.
Next.js standalone output produces a self-contained server with minimal dependencies, ideal for tiny Docker images. Here's how to build it correctly, handle env vars, and avoid the common image-bloat traps.
A bad deploy is going out right now — what do you do? Here's a calm, fast rollback playbook covering instant rollbacks, database migrations, and how to prevent the next one.
From your MongoDB connection string to connecting, indexing, and avoiding the classic schema mistakes. A practical setup guide with Mongoose and the native driver.
A complete walkthrough for shipping a SvelteKit app with a PostgreSQL database to production, covering the right adapter, environment wiring, migrations, and avoiding the classic cold-start gotchas.
How to right-size CPU and memory for your containerized app: understanding requests vs limits, reading the symptoms of under- and over-provisioning, and picking the right compute tier without overpaying.
Self-host Metabase for analytics and dashboards: why you must use an external application database, JVM memory tuning, connecting your data warehouse, and securing public sharing.
Self-host Open WebUI as a polished ChatGPT-style frontend for your LLMs, backed by managed Postgres for users and chat history, with auth and provider keys configured right.
Medusa is a modular e-commerce backend that needs PostgreSQL, Redis, and a worker process in production. This guide covers the full architecture, config, migrations, and a clean cloud deployment.
Deploy Rails to production with a managed PostgreSQL database: a tuned Dockerfile, Puma config, asset precompilation, migrations, Sidekiq workers, and the env vars that keep it secure.
VitePress turns Markdown into a fast, searchable docs site. Learn how to build for production, set the base path correctly, add search, and deploy your documentation to the edge for free.
When a deploy goes wrong, speed matters. Learn how rollbacks work, why database changes complicate them, the difference from rolling forward, and how to make rollbacks a non-event.
A practical guide to running scheduled tasks in the cloud — cron syntax, idempotency, timeouts, retries, and why a server crontab is the wrong place for production jobs.
Preview deployments give every pull request its own live URL. Learn how they work, how to handle databases and secrets in ephemeral environments, and how to wire them into your review flow.
A practical guide to deploying KeystoneJS 6 to production with a managed PostgreSQL database, persistent media storage, and automatic SSL — no Dockerfile gymnastics required.
Ktor is JetBrains' lightweight, coroutine-based Kotlin framework for building asynchronous servers. Learn how to package it as a fat JAR or container and deploy it to production with a managed database.
A practical guide to containerizing and deploying a Micronaut JVM application to production, including health checks, graceful shutdown, GraalVM native images, and wiring a managed PostgreSQL database.
Uptime Kuma is a beautiful self-hosted uptime monitor and status page. Learn how to deploy it durably with persistent storage so your monitor history and configuration survive restarts.
Deploy a WhatsApp bot using the WhatsApp Cloud API: setting up the webhook, verifying the challenge, validating payload signatures, sending messages, and running it as an always-on cloud service.
A production Laravel deploy with PHP-FPM and Nginx in one container, queue workers, scheduler via cronjob, config caching, and a managed MySQL. The PHP-on-modern-cloud playbook.
Remix runs as a long-lived Node server, which makes it a natural fit for containers plus a managed Postgres. Here's a full-stack deploy with loaders, actions, and Prisma wired end to end.
SolidJS ships as a static SPA; SolidStart is full-stack SSR. Here's how to deploy both — the SPA as a free static site, the SSR app as a container — with build config and routing.
Storybook builds to a self-contained static bundle, which makes it perfect for static hosting. This guide walks through building, optimizing, and deploying your component library so your whole team can browse it.
NocoDB turns any database into a smart spreadsheet UI — an open-source Airtable alternative. This guide deploys NocoDB with managed PostgreSQL for durable, multi-user data.
Outline is a fast, modern team knowledge base. This guide deploys it with managed PostgreSQL and Redis, configures SSO authentication, and sets up object storage for attachments.
Whether you run Droplets, App Platform, or Managed Databases on DigitalOcean, this guide maps each to its PandaStack equivalent and walks the migration — apps, data, domains, and the manual-ops you get to stop doing.
Hono runs anywhere JavaScript runs, which is its strength and its first deployment decision. This guide covers picking a runtime adapter, building a Node or Bun container, and shipping a Hono API to production.
Phoenix LiveView delivers real-time UIs over WebSockets with server-rendered state. This guide covers Elixir releases, the SECRET_KEY_BASE and Ecto config, WebSocket-aware deployment, and Ecto migrations.
Sanic is a fast async Python web framework with its own production server. Learn how to deploy a Sanic API with multiple workers, a database connection pool, and a tuned container.
tRPC gives you end-to-end type safety without code generation, but deploying it means deciding how server and client ship together. This guide covers the monolith and split-service approaches and the gotchas of each.
Self-host n8n for workflow automation: why you need an external Postgres, the encryption key that protects your credentials, webhook URLs, and choosing between single-instance and queue mode.
Turn your SvelteKit app into a fully static site with adapter-static and prerendering. Learn how to configure, build, and deploy it to a global CDN with automatic SSL.
Deploy a LlamaIndex retrieval-augmented generation service to production: separate ingestion from querying, persist your index, and serve grounded answers over HTTP.
Self-host Qdrant for vector search: deploy it with persistent storage, secure it with an API key, tune collection parameters, and decide when a dedicated vector DB beats pgvector.
Deploy a reliable Stripe webhook endpoint in Node: verify signatures with the raw body, make handlers idempotent, and handle the events that actually matter for billing.
Deploy a python-telegram-bot to production: the crucial polling-vs-webhook decision, which hosting shape each one needs, securing the token, and persisting conversation state.
Flask's dev server isn't for production. Learn how to deploy Flask properly with Gunicorn, the right worker model, a Dockerfile, health checks, and a managed database.
Go compiles to a single static binary, which makes it ideal for tiny production images. Here's how to build a minimal Docker image for a Gin API, add graceful shutdown, and wire in a managed database.
Hugo builds entire sites in milliseconds. Learn how to build for production, pin your Hugo version, handle the base URL correctly, and deploy your static site to the edge for free.
Deploy a Quarkus app to the cloud with JVM or native images, fast startup, health endpoints from SmallRye, and container-aware JVM settings — plus a Git-based deploy.
Strapi needs a real database and persistent media storage in production. This guide covers the right database config, secret keys, uploads to object storage, and a clean Docker deployment.
Ship a Symfony app to production the right way: prod environment caching, Doctrine migrations, PHP-FPM behind a web server, OPcache tuning, and a Git-based deploy.
Deploy a SolidStart app to the cloud: understand Vinxi/Nitro presets, choose server vs static rendering, handle server functions, and deploy with a single Git push.
n8n is a powerful open-source Zapier alternative. Learn how to self-host it in queue mode with PostgreSQL and Redis so your workflows survive restarts and scale under load.
Payload is a code-first, TypeScript-native headless CMS that runs as part of your Node app. This tutorial covers its config-as-code model, database choice, file storage, and a clean production deployment.
Plausible is a lightweight, privacy-friendly Google Analytics alternative. Learn how to self-host its full stack — the Elixir app, PostgreSQL, and ClickHouse — for cookie-free web analytics.
A practical, end-to-end guide to deploying a Vue.js single-page app: production builds, SPA routing fallbacks, caching headers, environment variables, and custom domains with automatic SSL.
Wrapping model inference in a FastAPI service gives you a clean, scalable API. This guide covers async endpoints, streaming responses, concurrency limits, and deploying inference that won't fall over under load.
Running your own Mastodon instance means orchestrating web, streaming, and Sidekiq processes plus PostgreSQL and Redis. This guide breaks down the architecture and deploys it piece by piece.
Deploy Rails 7+ with a managed Postgres: an optimized Dockerfile, Puma tuning, assets precompiled, migrations as a release step, and Solid Queue or Sidekiq for background jobs.
Temporal makes distributed workflows durable and reliable, but deploying workers correctly takes care. This guide covers connecting to Temporal Cloud or self-hosted, deploying workers, and scaling them.
Laravel Octane keeps your app booted in memory for dramatically higher throughput. This guide covers choosing FrankenPHP vs Swoole, containerizing Octane, and the stateful-app pitfalls that bite teams in production.
Sanity Studio is a single-page React app that talks to a hosted content lake, which makes it a perfect static-site deployment. Here's how to self-host the Studio with CORS, custom domains, and SSL.
Vaultwarden is a lightweight, self-hosted server compatible with Bitwarden clients. This guide deploys it securely with persistent storage, HTTPS, and the hardening a password vault demands.
Medusa needs PostgreSQL, Redis, and a worker process to run well in production. Here's how to deploy the backend correctly, including the server/worker split and the environment variables that trip people up.
KeystoneJS gives you a typed schema, a GraphQL API, and an admin UI from a single config file. Here's how to deploy it to production with PostgreSQL, the right build commands, and clean migrations.
Micronaut's compile-time dependency injection gives fast startup and low memory, ideal for containers. This guide covers building a JAR or GraalVM native image, configuring datasources, running Flyway, and deploying.
Rocket is a batteries-included Rust web framework with a focus on ergonomics. This guide covers its critical address config gotcha, a multi-stage build, database pools via fairings, and production deployment.
Astro's server-side rendering mode with the Node adapter lets you build dynamic, database-backed sites. Learn how to deploy an Astro SSR app to production with PostgreSQL.
Run the self-hosted Ghost publishing platform backed by MySQL 8: the config that matters, persistent storage for uploaded images, mail for member emails, and going live with SSL.
A practical walkthrough for deploying a GraphQL Yoga server backed by PostgreSQL: containerizing the app, wiring up the database connection, and shipping it to production with a git push.
Nuxt is the full-stack Vue meta-framework with SSR and server API routes powered by Nitro. Learn how to deploy a Nuxt app to production with a managed PostgreSQL database.
Love Supabase Edge Functions but want them next to your app and database? Learn how to build and deploy serverless edge functions on PandaStack as a Supabase alternative.
Wrap a LangChain agent in a FastAPI service and deploy it to production with streaming responses, timeouts, memory, and the cost controls agents always need.
A practical walkthrough for building and deploying a Twilio SMS webhook handler that validates signatures, replies with TwiML, and survives carrier retries in production.
Build a self-hosted Whisper speech-to-text API with faster-whisper, handle long audio with async jobs, and deploy it on the right compute tier without overpaying.
Bun is fast at install, build, and runtime. Learn how to containerize a Bun app for production, use the built-in HTTP server and SQL client, and deploy it to the cloud with a managed database.
Deno's security-first permission model and built-in tooling change how you deploy. Here's how to containerize a Deno app, set the right permission flags, and wire in a managed database.
A practical guide to taking FastAPI from localhost to a production deployment with Gunicorn + Uvicorn workers, a managed PostgreSQL database, migrations, and zero-downtime releases.
Deploy a NestJS API to the cloud the right way: a multi-stage Docker build, proper production config, graceful shutdown, health checks, and a managed database wired in automatically.
Deploy Spring Boot to production with a layered Docker image, JVM container settings that actually respect memory limits, Actuator health probes, externalized config, and a managed database.
Deploy a LangChain app to production: wrap it in an API, manage API keys and rate limits, stream responses, add a vector store, and handle long-running calls reliably.
Deploy your own LLM inference API to the cloud: pick a serving runtime, size CPU vs GPU honestly, handle model loading and memory, and front it with a clean API.
Meilisearch delivers typo-tolerant, instant search with a delightful developer experience. Learn how to deploy it securely with a master key, persistent storage, and production-ready settings.
MinIO gives you S3-compatible object storage you fully control. Learn how to deploy it with persistent volumes, secure credentials, and the right configuration for production workloads.
PocketBase is a single-binary backend with auth, a database, file storage, and a realtime API. Learn how to deploy it durably and why persistent storage is the one thing you can't skip.
Actix Web is one of the fastest web frameworks in any language. Learn how to package an Actix app into a small container image and deploy it to production with proper worker and database configuration.
Strapi defaults to SQLite, which falls apart in a containerized world. Here's how to connect Strapi 5 to a managed PostgreSQL database and deploy it cleanly to production.
Supabase is an open-source Firebase alternative built around PostgreSQL. Learn what its multi-service stack actually contains and the realistic ways to self-host it on a cloud platform.
Deploy a Docusaurus documentation site: configuring the build and base URL, optimizing for static hosting, handling versioned docs and search, custom domains with SSL, and continuous deploys from Git.
Deploy a Flask-SocketIO realtime application to production: choosing the right async worker (eventlet/gevent), enabling WebSocket transport, scaling with a Redis message queue, and sticky-session considerations.
Deploy a Gradio machine-learning demo to production: configuring the server for containers, loading models efficiently, handling concurrency and the queue, authentication, and going from notebook to a shareable URL.
Deploy a gRPC service to production: HTTP/2 ingress requirements, health checks and reflection, TLS, load-balancing long-lived connections, and a clean container build from your protobuf definitions.
Eleventy produces clean, dependency-light static HTML. Here's how to build and deploy an 11ty site for free, with build config, custom domains, automatic SSL, and a tip on data cascades.
Hugo builds thousands of pages in milliseconds and outputs pure static files. Here's how to host a Hugo site for free with the right build config, base URL handling, and automatic SSL.
Deploying Laravel in production means more than uploading code — you need PHP-FPM, migrations, a queue worker, and a real MySQL database. This guide containerizes a Laravel app and wires it to managed MySQL.
Quarkus brings fast startup and low memory to Java. Here's how to deploy it as a JVM container or a GraalVM native image, with a managed Postgres wired in via JDBC.
Gitea is a lightweight, self-hosted Git service with a GitHub-like UI. This guide deploys Gitea with persistent storage, managed PostgreSQL, and working SSH for git operations.
Matomo is the leading privacy-first, self-hosted alternative to Google Analytics. This guide deploys Matomo with a managed MySQL database, handles the archiving cron, and gets tracking live.
Payload CMS runs as a Node app on top of Next.js with your choice of database. This guide covers deploying Payload with the PostgreSQL adapter, handling migrations, and configuring media storage for production.
Fresh is Deno's island-based web framework with no build step and server-side rendering by default. This guide covers containerizing a Fresh app on the Deno runtime and connecting it to a PostgreSQL database.
Koa is a minimal, middleware-driven Node framework that leaves architecture up to you. This guide covers structuring a Koa API with a PostgreSQL pool, graceful shutdown, and a clean container deploy.
Run Celery in production with Redis as the broker: separating web and worker processes, concurrency and prefetch tuning, Beat for schedules, and the result-backend decision.
React Router v7 (the merge with Remix) introduces framework mode with SSR, loaders, and actions. Learn how to deploy a React Router v7 app to production as a Node server or static SPA.
Take a discord.js bot from your laptop to always-on hosting: gateway vs HTTP interactions, registering slash commands, why a bot is a worker not a web service, and adding persistence.
Add a Sidekiq worker to a production Rails app: the Redis connection, concurrency vs the database pool, queues and priorities, and running the web and worker processes as separate services.
Deploy a Qwik City app to production: understand resumability and adapters, pick the Node or static output, configure server endpoints, and deploy with one Git push.
Shipping a full-stack app means coordinating a frontend, an API, and a database. This tutorial walks through the architecture decisions, environment wiring, and a clean deploy from git push to live URL.
Koa is the minimalist, middleware-first Node framework from the Express team. This tutorial covers its async middleware model, production error handling, and a clean container deploy with a managed database.
FastAPI's async speed shines only when the database layer keeps up. This tutorial covers async SQLAlchemy, connection pooling, migrations with Alembic, and deploying FastAPI with a managed PostgreSQL.
Grafana is the de facto standard for observability dashboards. Learn how to deploy it with a PostgreSQL backend, provisioned data sources, and dashboards-as-code so nothing is lost on restart.
Deploy a Blazor Server application to production with the SignalR circuit in mind: sticky sessions, WebSocket transport, container configuration, health checks, and connecting a managed database via EF Core.
Deploy a Jekyll static site to production: the build process and environment, configuring baseurl and url, managing Ruby dependencies with Bundler, custom domains with SSL, and continuous deploys from Git.
Deploy an MkDocs (and Material for MkDocs) documentation site: the build process, configuring site_url, search and plugins, optimizing the static output, custom domains with SSL, and continuous deploys.
Elysia on Bun is one of the fastest JavaScript API stacks around. Here's a production deploy: a slim Bun container, end-to-end types, a managed Postgres, and graceful shutdown.
Fresh is Deno's island-architecture framework with zero client JS by default. Here's how to containerize and deploy it to production with a managed database and live logs.
Flask's dev server isn't for production. Here's the right way: Gunicorn with tuned workers, a slim container, health checks, config via env, and an auto-wired managed Postgres.
A production-grade NestJS deployment: a tight multi-stage Dockerfile, graceful shutdown, health checks, config validation, and an auto-wired managed Postgres. From git push to live in minutes.
Ollama makes running open LLMs as simple as pulling a model. This guide covers containerizing Ollama, choosing compute, persisting model weights, and securing the API for self-hosted inference.
A practical guide to self-hosting Airbyte for ELT data integration, covering its architecture, resource requirements, and how to run the platform alongside a managed Postgres destination.
Baserow is an open-source no-code database with a friendly spreadsheet UI. This guide deploys Baserow with managed PostgreSQL and Redis for a production-ready, self-hosted setup.
Chatwoot is an open-source customer support and live chat platform. This guide deploys its web and worker processes with managed PostgreSQL and Redis for a production-ready help desk.
Listmonk is a blazing-fast, self-hosted newsletter and mailing list manager. This guide deploys it with managed PostgreSQL and wires up an SMTP provider for reliable delivery.
Prefect orchestrates Python data pipelines with retries, scheduling, and observability. This guide deploys a self-hosted Prefect server, a worker, and your flows for production orchestration.
Redis is the swiss-army cache, queue, and session store. Here's how to connect your app to managed Redis correctly — pooling, TLS, and patterns for caching and rate limiting.
Elysia is a Bun-first framework with end-to-end type safety and excellent performance. This guide covers building a Bun container, connecting PostgreSQL, and deploying an Elysia API to production.
Hanami 2 is a modern, modular Ruby framework with a clean architecture. Learn how to deploy it to production with PostgreSQL, ROM migrations, asset precompilation, and Puma.
Appwrite is a full backend-as-a-service you can run yourself. Here's how its multi-container architecture maps onto a managed platform, the required env vars, and what to watch for in production.
Stand up a fast, typo-tolerant Meilisearch instance in production: persistent storage, master keys and API key scoping, indexing your first documents, and keeping memory in check.
Deploy a discord.py bot to always-on hosting: the async event loop, app commands and syncing, privileged intents, why it's a worker process, and adding a database for state.
Build and deploy a GitHub webhook receiver that verifies HMAC signatures, routes by event type, and responds fast enough to avoid GitHub's delivery timeouts.
Self-host Langflow for building visual AI workflows: back it with managed Postgres, lock down the editor with auth, and expose flows as APIs your apps can call.
Take a Model Context Protocol server from stdio prototype to a production HTTP deployment with streamable transport, auth, and observability that AI clients can reliably connect to.
Add vector search to your app without a new service: enable pgvector on managed Postgres, choose HNSW vs IVFFlat indexes, and run fast similarity queries alongside your relational data.
Containerize and deploy an ASP.NET Core app: multi-stage publish, Kestrel port binding, health checks, forwarded headers behind a proxy, and a Git-based cloud deploy.
Gatsby's data layer and build pipeline are powerful but need the right production setup. Learn how to build, cache, handle environment variables, and deploy your Gatsby site to the edge.
A complete guide to deploying Laravel to the cloud with Docker, PHP-FPM + Nginx, a managed MySQL database, queue workers, scheduled tasks, and the production config that actually matters.
Learn how to point a custom domain at your deployed app and get automatic HTTPS — covering DNS records, CNAME vs A records, the ACME challenge, and common propagation pitfalls.
Background tasks turn a slow Django request into an instant one. This tutorial covers deploying Django with Celery workers and Redis as the broker, including the separate-process architecture you need in production.
Directus wraps any SQL database with an instant REST and GraphQL API plus an admin app. This tutorial covers deploying Directus as a container, wiring PostgreSQL, persisting uploads, and securing it for production.
Metabase gives your team self-serve BI dashboards without writing SQL. Here's how to deploy it with an external PostgreSQL application database so your questions and dashboards persist.
Fastify is the high-throughput, low-overhead Node framework. Here's a production deploy with schema validation, structured logging, graceful shutdown, health checks, and a managed Postgres.
JupyterHub gives a team multi-user, authenticated notebook access. This guide covers deploying a JupyterHub server, persisting notebooks, securing access, and the tradeoffs versus single-user Jupyter.
Cal.com is the open-source Calendly alternative. This guide deploys the Next.js app with managed PostgreSQL, configures calendar integrations, and handles the env-heavy setup correctly.
A complete walkthrough for shipping a Go Fiber API to production with a small static binary, a tiny multi-stage Docker image, graceful shutdown, and a managed Postgres backend.
Actix Web is one of the fastest Rust web frameworks. This guide covers a multi-stage Rust build for a tiny container image, binding correctly, connecting PostgreSQL with sqlx, and deploying to production.
Blitz.js layers a zero-API data layer and auth onto Next.js, so deploying it is deploying Next.js with a few Blitz-specific steps. This guide covers the build, Prisma migrations, session secrets, and going live.
Echo is a high-performance, minimalist Go web framework. Learn how to deploy an Echo API to production with PostgreSQL, a tiny static binary, graceful shutdown, and connection pooling.
Ktor is JetBrains' lightweight Kotlin framework for asynchronous servers. This guide covers building a fat JAR with the Ktor Gradle plugin, configuring host and port, connecting PostgreSQL with HikariCP, and deploying.
Litestar is a fast, batteries-included ASGI framework and a strong FastAPI alternative. Learn how to deploy it to production with Uvicorn/Granian, a database, and a tuned Dockerfile.
AnalogJS is the meta-framework for Angular, bringing SSR, file-based routing, and API routes powered by Vite and Nitro. Learn how to deploy an Analog app to production as a Node server.
Chi is a lightweight, idiomatic Go router built on net/http. Learn how to deploy a Chi-based API to production with middleware, graceful shutdown, and a minimal container image.
Encore.ts is a backend framework with built-in infrastructure primitives and a high-performance Rust runtime. Learn how to self-host an Encore.ts backend in a Docker container with PostgreSQL.
Self-host the Hasura GraphQL Engine on top of PostgreSQL: container config, the environment variables that actually matter, metadata migrations, and locking down the admin secret before you go live.
Deploy a complete Medusa v2 commerce stack: the backend with its admin and worker modes, a Next.js storefront, the shared Postgres and Redis, and how the two services talk in production.
Self-host Flowise, the drag-and-drop LLM app builder, with a persistent database, authentication, and API keys so your chatflows survive restarts and stay private.
Skip Redis entirely: Graphile Worker runs a fast job queue inside your existing PostgreSQL. Here's how to deploy it, define tasks, schedule crontab jobs, and keep it healthy.
Deploy an AdonisJS 6 app with a managed PostgreSQL database: build the production bundle, run Lucid migrations safely, configure the database connection, and ship via Git.
A practical guide to taking a Fastify API from localhost to production: Dockerfile, graceful shutdown, health checks, environment config, and a one-command Git deploy.
Ghost is a professional publishing platform that needs MySQL 8, persistent storage, and correct mail config in production. Here's how to deploy the official Docker image the right way.
Deploy a production Express API backed by PostgreSQL: connection pooling, migrations, graceful shutdown, health checks, and a Git deploy with an auto-wired managed database.
Apollo Server makes building a GraphQL API straightforward, but production needs the right setup: a standalone server, schema hardening, query limits, and a managed database. Here is how to ship it safely.
Hono is a tiny, blazing-fast web framework that runs everywhere. This tutorial shows how to deploy a Hono API as a long-running container, with the runtime choices and database wiring you need.
A clean, end-to-end guide to deploying an ASP.NET Core Minimal API: container configuration, EF Core with a managed database, health checks, OpenAPI, and going from git push to a live HTTPS endpoint.
Celery Beat is the scheduler that fires periodic tasks into your Celery workers. Running it in production means getting the worker, the beat process, and the broker right — and avoiding duplicate runs.
Real-time Django needs ASGI, not WSGI. Here's how to deploy Django Channels with Daphne or Uvicorn, a Redis channel layer, sticky connections, and a managed Postgres.
Go's static binaries make for tiny, fast container images. Here's a Gin REST API deployed with a scratch-based multi-stage build, graceful shutdown, health checks, and an auto-wired Postgres.
Formbricks is an open-source, privacy-first survey and experience management platform. This guide deploys the Next.js app with managed PostgreSQL and configures in-app and link surveys.
Dev, staging, and prod need different config without different code. Here's how to manage environment-specific configuration with env vars, the 12-factor way, plus secrets handling.
Edge functions give you low-latency API routes that run close to users. Here's when to use one, how to deploy it, and the constraints (no long connections, cold starts) to plan around.
Deploy CodeIgniter 4 to production the right way: a lean Dockerfile, correct base URL and environment handling, database setup, and the security flags most tutorials forget.
Directus wraps any SQL database in an instant REST and GraphQL API plus an admin app. This guide covers deploying the official Docker image with PostgreSQL, secrets, caching, and file storage for production.
Take Apollo Server from localhost to a production deployment: standalone vs Express integration, health checks, caching, and connecting a managed database without hand-managing credentials.
Self-host Budibase, the low-code platform for internal apps: its multi-service architecture, the app database plus search dependency, and the secrets that keep your deployment secure.
Astro builds blazing-fast static sites by default. Learn how to build for production, when you need an adapter, and how to deploy your Astro site to the edge for free.
Eleventy is a zero-config, dependency-light static site generator that ships no client JavaScript by default. Learn how to build for production, set path prefixes, and deploy to the edge for free.
Deploy a Celery worker to production: choose a broker, run workers as long-lived processes, handle concurrency and graceful shutdown, and add scheduled tasks with Beat.
Keep a Discord bot online 24/7: gateway vs HTTP interactions, persistent state, graceful reconnection, secure token handling, and a always-on cloud deployment.
A step-by-step tutorial on wiring a managed database into your application — connection strings, pooling, SSL, environment variables, and the mistakes that cause production outages.
A working DRF API on localhost is not production-ready. This tutorial covers Gunicorn, static files, database config, migrations, and security settings to ship your Django REST Framework API safely.
AdonisJS is a full-featured Node MVC framework with a built-in ORM, migrations, and an ace CLI. This guide walks through building, configuring APP_KEY, running Lucid migrations, and deploying to production.
Deploy Appsmith, the open-source internal-tool builder: its MongoDB and Redis dependencies, the encryption keys that protect datasource credentials, and connecting it to your production databases.
Buffalo is a Rails-like full-stack Go framework with asset pipelines and migrations built in. Learn how to deploy a Buffalo app to production with Pop migrations and a managed database.
Deploy ComfyUI as a headless image-generation backend: expose its API, persist models and workflows, and right-size compute for Stable Diffusion pipelines.
Faktory is a language-agnostic background job server from the creator of Sidekiq. Here's how to deploy the server with persistent storage, secure it, and connect workers in any language.
Appwrite is a full backend-as-a-service with auth, databases, storage, and functions. Learn how its multi-container architecture works and how to self-host it on a cloud platform.
Deploy a Node.js BullMQ worker to production: separating producers from consumers, connecting managed Redis, configuring concurrency and rate limits, graceful shutdown, and scaling worker replicas.
Connecting Node.js to managed Postgres correctly means pooling, SSL, and a clean migration path. Here's a production-ready setup using pg, with notes for Prisma and Drizzle.
aiohttp is a low-level async HTTP framework for Python that gives you full control. Learn how to deploy an aiohttp service to production with Gunicorn workers, cleanup contexts, and a database pool.
Axum is the Tokio team's ergonomic Rust web framework built on Tower. This guide covers a layered Axum app with shared state, a sqlx PostgreSQL pool, multi-stage Docker builds, and production deployment.
Step-by-step guide to containerising an Express.js REST API and deploying it to production on PandaStack in minutes.
Learn how to containerise a Flask Python application and deploy it to production on PandaStack with zero infrastructure management.
Deploy your Vue.js SPA to a global CDN for free in minutes — connect your GitHub repo, configure pandastack.json, and push.
Deploy an Angular application to production on PandaStack — configure your build output, connect GitHub, and get an HTTPS URL automatically.
Deploy SvelteKit as a static site on PandaStack using the static adapter — faster builds, zero server costs, and GitHub-triggered deployments.
Deploy Nuxt.js in both static (SSG) and server-side rendering (SSR) modes on PandaStack — choose the right mode and deploy in minutes.
Deploy a plain HTML, CSS, and JavaScript website to a global CDN for free on PandaStack — no build tools, no framework, no cost.
Deploy a Laravel PHP application to PandaStack using Docker — containerise with PHP-FPM, connect PostgreSQL or MySQL, and deploy via GitHub.
Containerise a Spring Boot Java application with a multi-stage Dockerfile and deploy it to PandaStack with GitHub-triggered CI/CD.
Deploy a Ruby on Rails application to PandaStack using Docker — containerise with Puma, connect PostgreSQL, and ship via GitHub.
Learn how to set up PostgreSQL, create your first database, and run essential queries in this step-by-step developer tutorial.
Discover how to use Redis as a caching layer to dramatically reduce database load and cut API response times in your web application.
Get up and running with MongoDB in this hands-on tutorial covering documents, collections, CRUD operations, aggregation, and indexing.
A hands-on tutorial for Kubernetes CronJobs — covering the CronJob spec, concurrency policies, failure handling, and how PandaStack manages scheduled containers for you.
Set up automatic GitHub deployments on PandaStack so every push to your repository triggers a build and deploys your site instantly.
A complete guide to the pandastack.json configuration file — what each field does, how to set it correctly for your framework, and common examples.
Learn Docker from scratch — understand images, containers, and Dockerfiles, then deploy your first containerized app to the cloud.
Use Docker Compose to run your entire multi-service application stack locally with a single command.
Learn how Docker multi-stage builds dramatically reduce image size by separating build tooling from the final runtime image.
Set up a private Docker registry to host your container images securely, with authentication, TLS, and image retention policies.
Step-by-step guide to containerizing an existing application — from writing your first Dockerfile to running it in production.
Learn how to set up GitHub Actions workflows to automate your build, test, and deployment pipelines from scratch.
Set up a layered automated testing strategy in your CI/CD pipeline to catch bugs early, ship confidently, and keep deployment fast.
Containerizing WordPress with Docker gives you reproducible environments and deployment flexibility — here's how to do it right for production.
Apache OpenWhisk is a powerful open-source serverless platform — learn how to write, deploy, and invoke your first function using OpenWhisk on PandaStack.
Learn how to point a custom domain to your cloud app using DNS records, and get HTTPS automatically with Let's Encrypt.
Learn the exact techniques — logical replication, dual-write patterns, and cutover strategies — to migrate a live PostgreSQL database without any downtime.
A practical tutorial for wrapping a legacy application in a Docker container so it can be deployed on any modern cloud platform.
A hands-on tutorial for containerizing a multi-service legacy stack — web server, background workers, and scheduled tasks — using Docker and Docker Compose.
Deploy your Next.js application to PandaStack in under 10 minutes using the CLI or the dashboard. Static export or container — we cover both.
Learn how to deploy a Django application to PandaStack with a managed PostgreSQL database, environment variables, and automatic GitHub deploys.
PandaStack makes deploying React apps dead simple. Connect your GitHub repo, set the build command, and your app is live in minutes.
FastAPI is blazing fast. Pair it with PandaStack's managed PostgreSQL and container hosting for a production-ready API in minutes.
PandaStack offers managed PostgreSQL as part of its platform. Here's how to spin up a free database, connect to it, and manage it from the dashboard.
PandaStack does not sell managed WordPress, but you can run the official WordPress image as a container app with a managed MySQL attached. Here is how.
Run scheduled tasks in the cloud without managing cron servers. PandaStack lets you configure Docker-based cronjobs with a GUI or CLI.
Go apps compile to tiny binaries — perfect for container deployments. Here's how to Dockerize a Go app and deploy it to PandaStack in minutes.
PandaStack supports managed MySQL as a first-class database type. Spin one up in seconds, get your connection string, and connect from any app.
Push to GitHub and your site deploys automatically. PandaStack's GitHub integration makes static site hosting effortless with zero configuration.
Rails apps run great in Docker containers. This guide walks through containerizing your Rails app and deploying it on PandaStack with a managed PostgreSQL database.
Webhooks from Stripe, GitHub, or Twilio need a persistent public endpoint. Here's how to build and host one on PandaStack in under 30 minutes.
Running docker-compose in production is fine until it isn't. Here's how to move each service from compose to PandaStack while keeping downtime to zero.
The stack decisions that let you go from idea to paying users in 48 hours — and the ones that slow you down. This is what I'd actually use today.
Step-by-step guide to deploying a Node.js application completely free using PandaStack — including containers, environment variables, and a custom domain.
Connect your GitHub repo, configure your build, and have automatic deployments on every push — with rollbacks — in under 10 minutes. No YAML required.
PandaStack AI lets you describe your website in plain English and deploys a fully functional site in minutes — no code required. Here are real prompts and what they generate.