---
title: You built it with AI. Now what?
description: >-
  AI tools are incredible for writing code. But deploying to production still
  means servers, SSL, DNS, and databases. Here's how to close the gap.
date: '2026-04-14'
lastUpdated: '2026-04-15'
keywords:
  - deploy AI-built apps
  - AI coding tool deployment
  - flat rate app hosting
  - git push deployment
  - VPS alternative for developers
  - deploy cursor project
  - deploy claude code project
  - host vibe coding project
type: article
author: Ross Hill
locale: en_CA
site_name: MapleDeploy
slogan: Powerful hosting on Canadian soil
organization_url: 'https://mapledeploy.ca/'
logo: 'https://mapledeploy.ca//api/logo/lockup'
creator: MapleDeploy
publisher: MapleDeploy
founding_date: '2026-01-13'
email: hello@mapledeploy.ca
geo_region: CA-ON
geo_placename: Toronto
address_country: CA
area_served: Canada
application_category: DeveloperApplication
app_url: 'https://app.mapledeploy.ca'
llms_txt: 'https://mapledeploy.ca/llms.txt'
offers: >-
  Starter $45/mo, Pro $95/mo, Ultra $195/mo, Ultra 32 $395/mo, Ultra 64 $695/mo
  CAD
in_language: en-CA
canonical_url: 'https://mapledeploy.ca/blog/deploy-your-ai-built-project'
---

AI coding tools have changed what one person can build in a weekend. [Claude Code](https://www.anthropic.com/claude-code), [Cursor](https://cursor.com), [GitHub Copilot](https://github.com/features/copilot), [Windsurf](https://windsurf.com), [Bolt](https://bolt.new), [Lovable](https://lovable.dev), [v0](https://v0.app), [Replit Agent](https://replit.com). The list keeps growing. A solo developer can now produce a full-stack app, an API, and a SaaS prototype in the time it used to take to scaffold one project.

The output is real code, too. Not toy demos. In our experience, Claude Code can generate complete Nest.js backends with authentication middleware, and Cursor can scaffold Next.js apps with Tailwind, database schemas, and API routes. Bolt and Lovable produce full-stack React applications with working backends.

v0 generates UI components ready to drop into a Next.js project. Replit Agent builds applications with databases and authentication, then hosts them on Replit's infrastructure. Windsurf takes a similar approach to Cursor with its own take on context-aware code generation.

These tools output standard Dockerfiles, package.json files, requirements.txt, and docker-compose configurations. The code is production-shaped from the start.

This changes the deployment math. Not because deployment got harder, but because the ratio shifted. When writing code was the bottleneck, you deployed one or two things a month. When AI removes that bottleneck, you might have five projects in a weekend that are worth putting in front of users. The infrastructure model you choose needs to account for that.

## Per-project billing doesn't scale with prototyping speed

Most deployment platforms charge per application, per database, per service. Railway meters CPU, RAM, and egress. Heroku bills per dyno plus add-ons. [Render](/compare/render) charges per service instance. This is fine when you deploy one thing and iterate on it.

It breaks down when AI lets you build faster than you can evaluate. You spin up a prototype, add a database, expose an API. Then you build something else. And something else. Each one is small, but the per-project costs compound. A $10 database here, a $7 service there. Suddenly you're paying $80/month across four experiments, most of which you'll abandon within two weeks.

Here's a concrete example. Say you build three small projects in a weekend with Cursor: a Next.js SaaS app, a Flask API, and a Discord bot with a database.

On [Railway's Pro plan](https://railway.com/pricing) ($20 USD/month base), you pay per resource: roughly [$20 USD per vCPU per month, $10 per GB of RAM, and $0.15 per GB of storage](https://railway.com/pricing). A modest service and its Postgres database might run $15-30 USD/month combined, depending on actual usage. Three projects with databases could land in the $40-70 USD/month range.

On [Render](https://render.com/pricing), three web services at $7 USD each plus three Basic Postgres databases at $6 USD each puts you at $39 USD/month minimum. That's before you hit the resource limits that force an upgrade.

On [Heroku](https://www.heroku.com/pricing), three Basic dynos at $7 USD each plus three Essential Postgres instances at $5 USD each is $36 USD/month at the low end. Realistic production setups climb fast once you add logging and worker dynos.

The billing model was designed for a world where building was slow and deliberate. AI-assisted development isn't that.

## The last mile that AI doesn't cover

AI tools are excellent at generating application code. They're less helpful with the infrastructure around it. This is the gap that catches most people after the initial excitement of a working prototype.

DNS configuration is the first wall. Your app runs on localhost. Now you need it at a real domain. That means buying a domain, pointing DNS records, waiting for propagation, and debugging when the records don't resolve. AI tools can't do that for you.

SSL certificates come next. Browsers reject HTTP connections. You need HTTPS, which means provisioning and renewing TLS certificates. Let's Encrypt made this free, but the automation around certificate renewal still requires infrastructure.

Environment variables are another common stumbling block. Your AI-generated app has a `.env.example` with `DATABASE_URL`, `STRIPE_SECRET_KEY`, and `JWT_SECRET`. Locally, those are filled in. In production, you need a secure way to inject them into the runtime without committing secrets to your repo.

Database provisioning trips people up too. Your app expects PostgreSQL. Where does that database run? How do you create it, set credentials, run migrations, and handle backups? AI generated the schema and migration files. It didn't provision the actual database server.

Then there's the question of persistent storage, logging, and health checks. Production applications need all three. Setting them up from scratch on a bare VPS takes hours of configuration that has nothing to do with the code AI helped you write.

A managed platform handles all of this. MapleDeploy gives you automatic SSL on every deployment, one-click database provisioning, environment variable management through the Coolify UI, and custom domain configuration with clear DNS instructions. The gap between "it works on my machine" and "it's live on the internet" is exactly what the platform covers.

## Resource-based beats project-based

The alternative is to pay for resources, not projects. Get a server with defined CPU, RAM, and storage. Deploy as many applications and databases as fit. The cost doesn't change whether you're running one project or ten.

This is what MapleDeploy does. You get a dedicated VM starting at $45 CAD/month with 4 GB RAM, 2 vCPUs, and 35 GB storage. Within that, deploy whatever you want: a Next.js frontend, a Flask API, a PostgreSQL database, a Redis cache. No per-project fees, no usage metering. The price is the same at the end of the month regardless of how many experiments you ran.

Those three projects from the earlier example? On MapleDeploy, they all run on a single Starter instance. $45 CAD/month total, not $40-70 USD across three separate billing streams. If your experiments grow and you need more headroom, upgrade to Pro ($95 CAD/month, 8 GB RAM, 4 vCPUs) and keep deploying without restructuring anything.

Connect your GitHub or GitLab repo, push to a branch, and the platform builds and deploys automatically. Need Postgres? One click. Redis? Same. Real-time deployment logs, automatic SSL, custom domains.

## The infrastructure decision AI builders skip

Here's the part most AI-assisted development posts don't cover. Your code has to live somewhere. And where it lives is a [jurisdiction decision, not just a hosting decision](/blog/us-cloud-act-canadian-businesses).

Most of the popular deployment platforms run on US cloud infrastructure. Railway's [deployment regions](https://docs.railway.com/reference/deployment-regions) cover the US (California and Virginia), the Netherlands, and Singapore, with no Canadian option. [Render](/compare/render) runs on US cloud infrastructure. Heroku runs on AWS. Even when these platforms offer non-US regions, the parent companies are US-incorporated and subject to US data access laws.

MapleDeploy runs on [Canadian infrastructure](/canadian-hosting) in Toronto. That might not matter for a weekend experiment. But if the experiment turns into a real product with real users, especially users in regulated industries like healthcare or legal tech, you'll be glad the foundation was right from the start.

Retrofitting data residency after launch is painful. It means migrating databases, updating DNS, re-provisioning infrastructure, and potentially re-architecting how your application handles data. Starting with Canadian infrastructure is free. Moving to it later is not.

## Open source underneath

MapleDeploy runs on [Coolify](https://coolify.io), an [open-source platform](/open-source-stack) with 50,000+ GitHub stars. No proprietary runtime. No vendor lock-in. Your Dockerfiles and databases are standard. If you outgrow MapleDeploy or want to self-host, you take everything with you.

Coolify supports a wide range of deployment methods out of the box. Push a Dockerfile and it builds and runs it. Push a Node.js, Python, or Go project and [Nixpacks](https://nixpacks.com/docs/getting-started) detects the language and builds automatically. Docker Compose files work directly. You can deploy static sites, full-stack frameworks, databases, and background workers from the same interface.

This matters for AI-built projects specifically. AI tools generate standard code: Dockerfiles, package.json, requirements.txt. That code deploys to Coolify without modification. No platform-specific configuration files, no proprietary buildpacks to learn. A Next.js app that Claude Code scaffolded deploys the same way a hand-written one does. A Flask API that Cursor generated uses the same Dockerfile pattern you'd write yourself.

The management layer is the difference between MapleDeploy and self-hosted Coolify. We handle the VM, operating system updates, security patches, backups, and monitoring. You get the flexibility of an open-source platform without the ops burden of maintaining the server it runs on.

Self-hosting Coolify is a legitimate option if you enjoy server administration. But if you'd rather spend your time building and shipping, the managed version removes the distraction. Your AI coding tool generates the application. MapleDeploy runs it.

---

AI tools changed what gets built. The deployment model needs to catch up. Per-project billing made sense when projects were expensive to create. Resource-based pricing makes sense when they're cheap to create and expensive to evaluate. MapleDeploy gives you a dedicated server on [Canadian infrastructure](/canadian-hosting), flat pricing starting at $45 CAD/month, and a 30-day free trial. Build five things this weekend. [Deploy all of them](/#pricing).

{% cta-section title="Ship what you built" %}
30-day free trial. Push your repo, get a live URL. Plans start at $45 CAD/month.
{% /cta-section %}