• Docs
  • Changelog
Sign in
Get started
    • Home
    • Your first deploy
    • Free instances
    • Platform features by plan
    • Use with coding agents
    • FAQ
    • Templates
      • Migrate from…
        • Heroku
        • Railway
    • Compute plans
    • SandboxesBeta
      • Service types
        • Which to use?
        • Static sites
        • Web services
        • Private services
        • Background workers
        • Cron jobs
        • Workflows
        • Multi-service architectures
      • Data storage
        • Render Postgres
        • Render Key Value (Redis®-compatible)
        • Persistent disks
    • How deploys work
    • Supported languages
    • Git providers (GitHub, etc.)
    • Build pipeline
    • Deploy hooks
    • Monorepo support
    • Troubleshooting deploys
      • Previewing changes
        • Single-service previews
        • Preview environments (multi-service)
      • Docker deploys
        • Overview
        • Deploy a registered image
        • Using secrets
      • Runtime
        • Native runtimes
        • Environment variables & secrets
        • Default environment variables
    • Intro to sandboxes
    • Limits & pricing
      • How to…
        • Create & configure sandboxes
        • Execute commands
        • Upload and download files
        • Manage snapshots
      • Use with…
        • Claude Managed Agents
        • Cursor Cloud Agents
        • OpenAI Agents API
      • SDK/CLI reference
        • TypeScript SDK
        • Python SDK
        • CLI commands
    • Intro to workflows
    • Tutorial
    • Limits & pricing
      • How to…
        • Define tasks
        • Define flowsNew
        • Trigger runs
        • Develop locally
      • SDK reference
        • TypeScript SDK
        • Python SDK
      • Example workflows
        • TypeScript examples
        • Python examples
    • Overview
    • Create & connect
    • Database credentials
    • Extensions
    • Version upgrades
    • Logical replication
    • Legacy instance types
      • Database recovery
        • Recovery & backups
        • High availability
      • Database performance
        • Read replicas
        • Connection pooling
        • Admin apps
        • Repacking tables
        • Troubleshooting performance
    • Regions
    • Inbound IP rules
    • Edge caching
    • WebSockets
    • TLS certificates
      • Custom domains
        • Overview
        • Cloudflare
        • Namecheap
        • Other DNS providers
      • Internal traffic
        • Private network
        • Private links
      • Outbound traffic
        • Default IP ranges
        • Dedicated IP addresses
        • Outbound bandwidth
        • Handling network changes
      • Static site config
        • Custom response headers
        • Redirects & rewrites
    • The Render Dashboard
    • SSH / Shell access
    • Projects & environments
      • Service actions
        • Scaling
        • Rollbacks
        • Maintenance mode
        • One-off jobs
      • Infrastructure as code
        • Blueprints overview
        • render.yaml reference
        • Terraform provider
    • In-dashboard metrics
    • Health checks
    • Uptime best practices
      • Logging
        • In-dashboard logs
        • Log streams (syslog/HTTPS)
      • OpenTelemetry (OTel) metrics
        • Provider setup
        • Metrics reference
      • Notifications
        • Webhooks
        • Email / Slack
    • MCP Server
      • Render CLI
        • Overview
        • Command reference
      • REST API
        • Overview
        • API reference
      • Third-party connections
        • OIDC support
        • Datadog
    • Workspaces, members, & roles
    • Login settings
    • Audit logs
      • Organizations
        • Overview
        • SAML SSO
    • DDoS protection
    • Platform maintenance
      • Compliance
        • Overview
        • HIPAA (US health data)
        • HIPAA best practices
        • Shared responsibility model
        • Pentest policy
    • Heroku vs Render
    • Vercel vs Render

Deploy RedwoodJS on Render

RedwoodJS is a full-stack framework for building and deploying JAMstack web applications. It consists of a React frontend and a Node backend that exposes a GraphQL API. Redwood uses Prisma to communicate with a database such as SQLite or PostgreSQL.

Check out our demo Redwood app running on Render here.

Getting started

  1. Create a new Redwood project by running yarn create redwood-app my-redwood-app in your terminal or by forking our Redwood demo from https://github.com/render-examples/redwoodjs.

  2. Read the Redwood Tutorial and Docs to learn how to create your custom Redwood application.

Preparing for deployment

Run the following command to configure your project for deployment to Render:

yarn rw setup deploy render

This command will:

  • Create a starter Blueprint Spec for infrastructure as code.

  • Define a health check endpoint at api/src/functions/healthz.js.

By default, this command will configure your project to use a Postgres database that is fully managed by Render. See Database Selection for more information.

Redwood typically uses an .nvmrc file to control the Node version. With Render, the Node version is controlled with the NODE_VERSION environment variable in the generated render.yaml file.

See Specifying a Node Version if you need to customize the version of Node.js used for your app.

Deployment

Once your Redwood project is ready for deployment to Render:

  1. Create a Render account.

  2. Create your services from a Blueprint spec https://dashboard.render.com/select-repo?type=iac by linking your Git provider account and selecting the repository for your Redwood project.

  3. Review and apply the changes.

  4. After deployment:

    • Navigate to the API service and obtain your onrender.com service URL.

    • Navigate to the web static site and click on Redirects/Rewrites.

    • Create a Rewrite rule pointing to the API service URL.

    • Click Save Changes.

Redwood Rewrite

  1. In your render.yaml file, replace the rewrite rule destination with the onrender.com service URL. This ensures that the rewrite rule will not change on subsequent deployments.

Database Selection

By default, the setup command configures your project to use PostgreSQL, which is recommended for production workloads. Render also supports deployments that use SQLite or any of the databases supported by Prisma.

Use the -d flag to override the default value (postgres):

  • yarn rw setup deploy render -d sqlite
  • yarn rw setup deploy render -d none

Before running the command, check that the data source provider in api/db/schema.prisma is correct. Otherwise:

  1. Correct the data source provider.
  2. Delete the migrations folder at api/db/migrations/.
  3. Run the following command: yarn redwood prisma migrate dev to run migrations for the new provider.

PostgreSQL (most reliable)

Render's fully managed PostgreSQL offering includes encryption at rest, automated backups, and expandable SSD storage.

Learn more.

SQLite (lowest cost)

SQLite allows you to run a small and fast SQL database engine that writes directly to disk on your API server. The advantage of SQLite is rapid local development, which translates to a low-cost cloud deployment.

See Appropriate Uses for SQLite for more information.

Adding a disk to a service prevents zero-downtime deploys.

Externally Hosted

To use an externally hosted database, add your connection URL as an environment variable named DATABASE_URL.

Deploy RedwoodJS on Render
  • Getting started
  • Preparing for deployment
  • Deployment
  • Database Selection
    • PostgreSQL (most reliable)
    • SQLite (lowest cost)
    • Externally Hosted
All Systems Operational
© Render Inc. All rights reserved.