The short version of everything people ask before signing up. For walkthroughs, see the docs.
Doable is a deployment platform built around one principle: shipping code should take one command. Type `doable deploy` in your terminal, or `/deploy` in Claude Code, and your app is live behind HTTPS in under a minute. No dashboard required to ship a deploy.
30–90 seconds for a typical small Node or Python app. Build-heavy projects with large dependency trees take longer. The breakdown is usually: tarball upload (1–3s), Docker build (most of the time, depends on your project), agent pull + start + healthcheck (10–20s).
No. Doable auto-detects Node (Next.js, Nuxt, Astro, SvelteKit, Remix, Express, Fastify, plain Node), Python (Flask, FastAPI, Django, Streamlit), and static sites. If you want full control, drop a Dockerfile in your repo root and Doable uses it as-is.
Yes, one cloud project, 20-minute build timeout, free `<slug>.doable.do` subdomain with HTTPS, no credit card required. Unlimited bring-your-own-server projects on every plan tier including Free.
Free for one project. Starter is $15/month for 3 cloud projects + 3 custom domains. Pro is $39/month for 10 cloud projects + 10 custom domains + priority builds. Bring-your-own-server projects are unlimited and free at every tier, you only pay your hosting provider.
No. Doable's pricing is flat per month. There's no metered bandwidth, no per-build minute, no per-function-invocation charge. The plan price is the entire bill.
The deploy fails with a clear error and the previous deploy stays live. You can either (a) optimise the build, (b) upgrade for a longer timeout (Free 20m → Starter 30m → Pro 40m), or (c) move the build to your own server with `doable deploy --target <byo-server>` where build timeouts don't apply.
Bring-your-own-server: install Doable's agent on a Linux host you own (Hetzner, DigitalOcean, your homelab, anywhere Docker runs) and deploy to it from the same CLI or AI tool you'd use for Doable Cloud. The deploy workflow is identical; only the target changes.
Yes. BYO is unlimited and free at every plan tier including Free. You only pay your infrastructure provider.
It's a single Go binary, ~12 MB, that runs as a systemd service. It long-polls the Doable control plane for tasks (build / deploy / stop / addon-provision) and runs them via the local Docker daemon. It's outbound-only, never opens an inbound port, and only manages containers it created itself, verified via the `doable.managed=true` Docker label.
Yes. The agent only touches containers it created. Existing services, manual containers, and anything outside Docker are untouched.
Doable detects the missed heartbeats and flips the server to `offline` status within 60 seconds. New deploys aren't scheduled to it until it comes back. When it does come back, the next heartbeat auto-promotes it to `online`, no manual intervention.
Doable ships an MCP (Model Context Protocol) server. Install once with `claude mcp add doable -- npx -y doable-mcp` and `/deploy` becomes available in any Claude Code conversation. The same MCP package works in Codex, Cursor, and any MCP-compatible client.
Yes, the `doable.logs` MCP tool returns logs by deployment ID. Claude can fetch them automatically when a deploy fails and reason about what to fix.
The CLI does everything the MCP server does. `doable login`, `doable deploy`, `doable logs`. Same workflow, different entry point.
Not on Doable Cloud yet, you attach an external Postgres URL via `doable addon attach`. Neon, Supabase, Upstash, or your own URL all work. The string is encrypted at rest and injected as an env var. On a BYO server you can opt in to native Postgres / Redis / MongoDB containers managed by the agent.
Because the dedicated managed-Postgres providers are very good, Neon and Supabase are excellent, run on accounts you already have, and aren't a margin opportunity for us to chase. We focus on the deploy half of the workflow and let database providers focus on theirs.
Encrypted at rest with AES-256-GCM using a master key that lives outside the database. Plaintext only exists in memory at container start time. The reveal endpoint is rate-limited and audit-logged so accidental shares leave a trail.
EU (Hetzner FSN1 region). The control plane database, build artifacts, and addon backups are all stored in EU data centres.
Yes. `DELETE /v1/me` (or the dashboard's delete-account flow) starts a 30-day soft-delete window during which you can contact support to restore. After 30 days everything is hard-purged: project rows, S3 artifacts, addon backups, audit logs (replaced with userId=null).
Build logs are stored on the control plane so you can view them in the dashboard. Runtime logs from your container go to the agent and are streamed on demand via `doable logs`, they're not persisted server-side beyond the request lifetime.
Yes. Every Doable project, Free, Starter, Pro, even anonymous previews, gets a `<slug>.doable.do` subdomain with automatic HTTPS via Let\'s Encrypt. No setup required.
0 on Free (subdomain only), 3 on Starter, 10 on Pro. Apex and subdomain count the same.
No. HTTPS via Let\'s Encrypt is included on every plan, every project. Renewals happen ~30 days before expiry without any user action.
We don't register domains in-app — `doable domain search <name>` checks availability/price (free) and points you at Namecheap, our affiliate partner. After you register there, run `doable domain connect <name> --project <id>` (or click Connect Domain in the dashboard) and Doable handles DNS + TLS. Doable earns a small referral commission at no extra cost to you.
Yes. Set Cloudflare to proxy your domain (orange cloud), point the CNAME at `cname.doable.do`, and run `doable domain connect`. Doable provisions an origin certificate and Cloudflare handles the edge cache.
Your working directory is bundled (respecting `.gitignore`), uploaded via a presigned URL to S3-compatible storage, built into a Docker image on Doable\'s build server, pushed to the image registry, and pulled by the target agent. The agent starts the new container behind Traefik with automatic HTTPS, runs a healthcheck, and flips traffic once it passes. Total time: 30–90 seconds for typical apps.
Yes, `doable rollback` (or the dashboard's rollback button) instantly switches traffic to the previous deploy\'s artifact without rebuilding. The full deploy history is kept and you can roll back to any past healthy deploy.
Yes. Doable starts the new container behind the scenes, runs a healthcheck, and only flips traffic once it passes. If the healthcheck fails, the previous container keeps serving and the deploy is marked failed, no downtime, no half-deployed state.
Yes, `doable deploy cancel <id>` (or the dashboard cancel button). The build worker stops, the deploy is marked cancelled, and the previous deploy keeps serving.
Node.js (Next.js, Nuxt, Astro, SvelteKit, Remix, Express, Fastify, plain Node), Python (Flask, FastAPI, Django, Streamlit), static sites (`dist/`, `build/`, `out/`), and any project with a Dockerfile. If detection picks the wrong stack, an explicit Dockerfile always wins.
Drop a Dockerfile in your repo root. Doable detects it and uses it as-is, install whatever system packages your build needs. The Dockerfile is the escape hatch for everything Doable\'s default builds can\'t handle.
For most apps it\'s a single command. The auto-detected runtime works the same as Heroku\'s buildpacks, Railway\'s Nixpacks, or Vercel\'s Node detection. Export env vars, run `doable env import`, then `doable deploy`. See the [migrate-from-Heroku guide](/use-cases/migrate-from-heroku) for the full walkthrough.
Yes. Your code stays a normal repo with auto-detected runtime (or a Dockerfile if you provided one). The build output is a standard Docker image you can pull yourself. There\'s no Doable-specific scaffolding to unwind, no proprietary build format. The same image you ran on Doable runs anywhere Docker runs.
External databases (Neon, Supabase, Upstash, Atlas) stay where they are, you attached connection strings, not data. Native BYO addons can be backed up with `doable addon backup` and restored anywhere. Account deletion (DELETE /v1/me) hard-purges everything Doable holds within 30 days.
We try hard to make sure there isn\'t. The CLI is open about formats; the build output is standard Docker; env vars export with `doable env export`; deploy artifacts download with `doable deploy artifact <id>`. Leaving should take less time than signing up.
Question not answered here?
Get in touch