• 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

Migrate MongoDB GraphQL to Render

MongoDB Atlas GraphQL is deprecated, with service ending in March 2025. Render provides a flexible, scalable, secure alternative for hosting your GraphQL API, including part or all of a federated GraphQL architecture.

About Render

Render is a cloud application platform that helps developers flexibly deploy and scale their apps and services. You can host your GraphQL API on Render alongside the entire rest of your stack (frontend and backend). Your GraphQL servers can fetch from all of the same data sources, including MongoDB Atlas.

Render makes it straightforward to auto-deploy code from a Git repo, configure private network communication, autoscale services, and more.

Before you begin

  1. Sign up for Render.
  2. Make sure your application source is either hosted in a repository on a Git provider or available as a prebuilt Docker image.

Migrate to Render

Always refer to the official documentation of both MongoDB Atlas and Render for the most up-to-date information.

Specific steps might vary depending on the details of your project and the technologies used.

To migrate your GraphQL app to Render from MongoDB Atlas App Services, you will deploy a GraphQL server on Render as a web service. Here are the steps:

  1. Choose a GraphQL server implementation.

    You can deploy virtually any GraphQL backend to Render. You might want to integrate an open-source framework like Apollo Server into an existing backend service or deploy a solution like Hasura GraphQL Engine as a standalone service.

    Render provides native runtime support for Node.js, Bun, Python, Ruby, Go, Rust, and Elixir. You can deploy GraphQL services in other languages via Docker.

  2. Deploy your GraphQL server on Render.

    Next, deploy your GraphQL server as a web service on Render. Each web service on Render automatically gets a public onrender.com URL, and you can set up a custom domain.

    • If you're integrating a GraphQL framework into an existing web service, follow our example guides for the web framework most relevant to you, such as Express, Django, or Ruby on Rails. See the full list of quickstarts for more options.
    • If you're starting from scratch, one option is to follow our Hasura GraphQL Engine quickstart guide to create a standalone GraphQL service.
  3. Connect your GraphQL server to your data sources.

    In many GraphQL API implementations, the data that backs the GraphQL API is stored in a database.

    You can provide your database's URL (also known as a database connection string) to your web service via an environment variable set on your web service. Then, you must configure your web service's code to use that environment variable to connect to the database.

    If your data source is MongoDB Atlas:

    • Follow this guide to learn how to connect your web service to Atlas.
    • See this quickstart for a code example. This example shows a Render web service that uses an environment variable to obtain an Atlas database URL.
  4. Update your client applications.

    Update any client applications that interact with your GraphQL API endpoints to point to your Render service's URL.

  5. Shut down Atlas App Services endpoints.

    After you verify that your GraphQL API endpoints are fully migrated and operational on Render, you can delete your MongoDB Atlas App Services app to avoid unnecessary costs. As a reminder, Atlas GraphQL endpoints are scheduled to shut down on March 12, 2025.

Next steps

Learn about other Render service types you can use as part of your GraphQL implementation.

For example, if you have a federated GraphQL architecture with a self-hosted gateway, you can deploy the gateway as a web service and your individual subgraphs as private services that only receive traffic from the gateway:

Migrate MongoDB GraphQL to Render
  • About Render
  • Before you begin
  • Migrate to Render
  • Next steps
All Systems Operational
© Render Inc. All rights reserved.