Host a converted Framer site on Render or Railway

To host a converted Framer site on Render or Railway, push the project to Git, create a web service from the repository, set the build command to npm ci && npm run build and the start command to npm start, and make sure the app listens on the port the platform gives it. Both platforms run long-lived Node.js processes, so they suit every Deframer target that needs a server: Next.js, TanStack Start, Astro and React Router. A static Vite export can go on Render's static sites instead.

Deframer is an independent tool and is not affiliated with, endorsed or sponsored by Framer, Render or Railway.

Why a Node.js platform

Vercel and Netlify are built around Next.js and static sites. Render and Railway are general platforms: they build your repository and keep a process running, much like a server you'd manage yourself, minus the server. That makes them a good fit for the targets whose production server is a plain Node.js command:

The detail that trips people up: the Astro and React Router server.ts default to HOST=localhost. On a platform, the router sends traffic to the container's network interface, so set HOST=0.0.0.0. Both platforms set PORT for you.

If you're still choosing a framework, which framework to export Framer to compares them.

Step 1: Get the project

1. Paste your published Framer site's address on deframer.co and pick the framework. Converting is free.
2. Pick where assets live. "Assets in the project" puts images, fonts and videos in public/, served by your app; the default keeps them on Framer's CDN.
3. Verify the site is yours with the meta tag shown, publish in Framer, and download. A verified download costs 1 credit (pricing). Downloads are for your own sites or sites whose owner has given permission.
4. Run it locally once:

npm install
npm run build
npm start

5. Push it to GitHub or GitLab, including package-lock.json.

Step 2: Pin the Node.js version

Both platforms pick a Node.js version from your project. The simplest way to pin it is the engines field in package.json:

{
  "engines": { "node": ">=22.22" }
}

Use the minimum from the table above for your target. Render also honours a NODE_VERSION environment variable or a .node-version file; Railway reads engines. Check each platform's current docs, since build systems change.

Deploying on Render

1. In the Render dashboard, create a new Web Service and connect the repository.
2. Runtime: Node.
3. Build command: npm ci && npm run build.
4. Start command: npm start.
5. Environment variables:

• NODE_ENV=production
• HOST=0.0.0.0 for Astro and React Router
• FORMS_WEBHOOK_URL and any FORMS_<NAME>_WEBHOOK_URL from .env.example

6. Health check path: / is fine for a marketing site.
7. Create the service. Render builds, starts it and gives you an onrender.com address.

If you'd rather keep the setup in Git, a render.yaml blueprint does the same:

services:
  - type: web
    name: my-site
    runtime: node
    buildCommand: npm ci && npm run build
    startCommand: npm start
    envVars:
      - key: NODE_ENV
        value: production
      - key: HOST
        value: 0.0.0.0
      - key: FORMS_WEBHOOK_URL
        sync: false

sync: false makes Render ask for the value in the dashboard instead of storing it in the file.

A static Vite site on Render

For the Vite target, create a Static Site instead: build command npm ci && npm run build, publish directory dist. Add VITE_FORM_ENDPOINT as an environment variable if the site has forms; it's compiled into the build. Render has its own redirect and rewrite rules in the dashboard, and doesn't read _redirects; copy the site's redirects from public/_redirects into them. Each page is written as about.html for /about; check that Render serves clean URLs for your setup, and add rewrite rules if it doesn't.

Deploying on Railway

1. Create a new project from your GitHub repository.
2. Railway detects a Node.js app and runs npm run build and npm start from package.json. If it doesn't, set them in the service's settings.
3. Add variables: NODE_ENV=production, HOST=0.0.0.0 for Astro and React Router, and your FORMS_… webhooks.
4. Under networking, generate a public domain to get a railway.app address.
5. Deploy.

Railway sets PORT and routes the public domain to it. If the deploy succeeds but the site doesn't answer, the app is almost always listening on localhost or a hard-coded port; check the logs for the address it printed on start.

Test before you move the domain

On the platform's own address:

1. Open every route in the README's routes table, including CMS pages and a URL that should 404.
2. Check that a URL with the wrong trailing slash redirects the way it did on Framer.
3. Test a few of your Framer redirects.
4. Submit each form and confirm the webhook receives it.

Then update public/robots.txt, public/sitemap.xml, and for Next.js metadataBase in src/app/layout.tsx, if the domain changes.

Custom domain

Both platforms let you add a custom domain on the service and show the DNS records to create, usually a CNAME for www and an option for the apex that depends on your DNS provider. They issue HTTPS certificates once DNS resolves.

1. Lower TTLs a day ahead.
2. Add the domain on the platform.
3. Change the records at your DNS provider.
4. Wait for HTTPS, test, then remove the domain from Framer.

The full order, with rollback, is in moving a domain off Framer without downtime.

Practical notes

• Sleeping instances. Free or low tiers on some platforms stop idle services and start them on the next request, which makes the first visit slow. For a public marketing site, use a plan that keeps the service running. Check each platform's current plan terms.
• One instance is enough to start. A prerendered site is light. A single instance also keeps the project's in-memory form rate limit as one counter.
• Logs. Without a form webhook, submissions are logged by the server, so you'll find them in the platform's logs. Set a webhook before launch.
• Preview environments. Both platforms can create environments per pull request. Preview deployments for a converted Framer site covers a review workflow.
• Updates. When you republish in Framer, convert again, merge the new output in Git and push; the platform redeploys. See maintaining a converted site with Git.

Render, Railway or something else?