# Deploy Medusa JS with One-Click Agentic AI Hosting in 2026 > Self-host Medusa in production on Kuberns with agentic AI. Just Provide secure env variables, click deploy, and launch your opensource backend in minutes. - **Author**: parth-kanpariya - **Published**: 2026-02-22 - **Modified**: 2026-09-09 - **Category**: Open Source - **URL**: https://kuberns.com/blogs/self-host-medusa-in-one-click-with-ai/ --- If you’re looking to deploy Medusa in production, you already know it’s not just another e-commerce template. [Medusa](https://medusajs.com/) is an open source, headless commerce engine built for developers who want full control over their backend. You can customise pricing logic, extend APIs, manage orders, integrate custom payment providers, and connect any frontend framework like Next.js. That flexibility is exactly why many teams choose a self-hosted Medusa setup instead of a SaaS ecommerce platform. Running Medusa in production is not just about starting a Node server. A proper deployment needs a PostgreSQL database, Redis for background jobs and caching, secure environment configuration, worker handling, HTTPS, and domain setup. If you try a typical Medusa Docker or VPS deployment, you’ll quickly notice that backend, worker, database, Redis, CORS, and SSL pieces all need to be wired together correctly. Kuberns removes that manual configuration work for open-source deployments by handling the infrastructure setup and orchestration for you. The easiest way to deploy Medusa JS in 2026 is to use a deployment platform that supports a Node.js backend, PostgreSQL, Redis, background workers, secure environment variables, HTTPS, and an admin dashboard. Kuberns is built for this kind of open-source deployment. Instead of asking you to manually connect databases, Redis, CORS, SSL, and worker services, Kuberns handles the deployment configuration while you provide the secure environment values required by the template. > The real question most developers end up asking is simple: how do you deploy Medusa without manually managing servers, containers, databases, Redis, SSL, CORS, and background workers? In this guide, we’ll break down how Medusa is typically deployed on other platforms, why it involves more setup than expected, and how Kuberns simplifies open-source Medusa deployment with agentic AI for deployment. If your goal is to run a stable, scalable Medusa self-hosted backend without DevOps overhead, this guide will walk you through the simplest path. ## TL;DR * Medusa is an open-source headless e-commerce backend designed for full customisation. * A Medusa self-hosted production setup needs PostgreSQL, Redis, secure environment variables, background workers, HTTPS, and a working admin dashboard. * With [Kuberns](https://kuberns.com/), you do not manually configure those infrastructure pieces. Kuberns handles the production setup for open-source deployments using agentic AI for deployment. * You choose the Medusa template, connect or fork the repository, provide the secure environment variables requested by the template, and click Deploy. ## What Does Medusa Need for Production Hosting? Medusa is a backend commerce engine, so production hosting is different from hosting a static storefront. The backend must serve APIs, run the Medusa Admin, connect to persistent data services, and process background jobs reliably. For a production Medusa setup, the important pieces are: * A Node.js runtime for the Medusa server * PostgreSQL for products, orders, customers, carts, pricing, and other commerce data * Redis for caching, sessions, events, locks, and workflow-related background tasks * Server and worker handling so API requests and background jobs do not fight for the same runtime * Secure environment variables for admin credentials, secrets, and app configuration * HTTPS, domain setup, and a reachable admin dashboard at `/app` * A health check endpoint, usually `/health`, to confirm the backend is live On a manual VPS or Docker setup, you normally configure each of these pieces yourself. On Kuberns, the Medusa template and Kuberns agent handle the infrastructure and deployment configuration for you, so the user-facing work is limited to selecting the template, connecting the repository, and adding the secure variables requested during setup. ## Best Ways to Host Medusa JS There are three common ways developers host Medusa JS in production. ### Option 1: Manual VPS or Docker Hosting This gives maximum control, but it also creates the most setup work. You need to configure the server, install the runtime, connect PostgreSQL and Redis, manage worker processes, set up SSL, handle deployments, and maintain the environment over time. ### Option 2: Generic Cloud or PaaS Hosting Platforms such as Railway, Render, Heroku, AWS, or DigitalOcean can run Medusa, but you still need to understand how the backend, database, Redis, worker, secrets, health checks, and admin URL fit together. This is easier than raw VPS hosting, but still requires deployment decisions. ### Option 3: Kuberns for Open-Source Medusa Deployment Kuberns is the simplest path for teams that want to self-host Medusa without turning the setup into a DevOps task. The production pieces Medusa needs are handled by Kuberns, and your main responsibility is to provide the secure environment variables requested by the template. ## Why Deploy on Kuberns? And How Medusa Is Deployed on Other Platforms Deploying Medusa on Kuberns is built around a simple idea: you should not have to configure infrastructure just to run an ecommerce backend. With Kuberns, Medusa deployment is handled through agentic AI for deployment and a one-click template flow. You start by selecting the Medusa template, connecting or forking the repository, adding the required secure environment values, and clicking Deploy. The Kuberns agent detects the application structure, prepares the correct runtime, builds the container, configures networking, and launches the backend in a production-ready state. You are not writing Dockerfiles. You are not provisioning PostgreSQL or Redis manually. You are not configuring CORS, reverse proxies, or SSL certificates yourself. > Now compare that with typical deployment methods. If you deploy Medusa on AWS or DigitalOcean, you first provision a server. Then you install Node.js, configure PostgreSQL, set up Redis, configure environment variables, manage process managers, configure HTTPS with Nginx, and ensure worker processes stay alive. Every component must be connected correctly. A misconfigured Redis instance can break background jobs. An incorrect environment variable can block payment flows. Platforms like Railway, Render, or Heroku simplify some parts, but you still need to attach databases, configure Redis add-ons, set memory limits, and define worker processes. These platforms reduce raw server management, but they do not remove application-level configuration complexity. > ***Medusa is not a static app. It is a commerce engine with background jobs, caching, and persistent storage requirements. Kuberns changes the model by combining one-click deployment with agentic AI for deployment. Instead of manually stitching services together, you provide secure template values and deploy Medusa as a complete system.*** | Deployment Factor | VPS | Render / Railway / Heroku | Kuberns (Agentic AI Deployment) | | -------------------------- | ----------------------- | ------------------------- | ---------------------- | | Server Provisioning | Manual | Managed | Automated | | PostgreSQL Setup | Manual install & config | Attach & configure | Pre-configured | | Redis Setup | Manual install & config | Add-on configuration | Auto-handled | | Environment Variables | Manual secure setup | Manual secure setup | Secure guided input | | Worker Process Handling | Manual process manager | Manual config | Auto-configured | | HTTPS & Domain Setup | Manual SSL & proxy | Platform-managed | Automatically enabled | | Scaling & Restarts | Manual monitoring | Platform dependent | Auto-managed | | Infrastructure Maintenance | High | Medium | Minimal | | DevOps Knowledge Required | High | Medium | Low | Other platforms give you infrastructure and expect you to assemble Medusa correctly. Kuberns assembles Medusa correctly and gives you the infrastructure automatically. That is the difference. ## Deploy Medusa on Kuberns in One Click Deploying Medusa on Kuberns is designed to give you full backend control without forcing you to manually configure databases, Redis, CORS, SSL, worker processes, or server infrastructure. Instead of assembling multiple services yourself, you start with a pre-configured Medusa deployment template built specifically for production use. Let’s walk through the process. ### Step 1: Select the Medusa Template Start by navigating to the [Templates page](https://kuberns.com/deploy). From there, choose the [Medusa one-click template](https://kuberns.com/deploy/medusa-js) and click Deploy. ![one click template fpr medusa deployment by kuberns](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/medusa-oneclick-template.png) The template is already structured for production deployment. The runtime configuration, backend setup, and service handling are pre-configured by Kuberns. You are not starting from scratch or wiring together backend, database, cache, CORS, and SSL settings manually. ### Step 2: Fork and Connect Your Repository Before deployment continues, fork the Medusa starter repository into your GitHub account. Forking gives you full ownership and customisation freedom. Medusa is designed to be extended, whether you're modifying product logic, adding plugins, or integrating custom payment providers. By deploying from your own repository, you maintain complete control over your e-commerce backend. ![medusa configuration on kuberns](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/medusa-configuration.png) After forking, connect your GitHub account in the Kuberns dashboard and select your forked repository. All future builds will be generated directly from your source code. ### Step 3: Add the Required Environment Variables ![Add env variables to run medusa](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/medusa-env-variables.png) For Medusa deployment on Kuberns, you only provide the secure environment variables requested by the template. | Environment Variable | Purpose | | -------------------- | ----------------------------------------------------- | | MEDUSA\_ADMIN\_EMAIL | The email used to create your Medusa admin account | | MEDUSA\_ADMIN\_PASSWORD | The password for accessing the Medusa admin dashboard | These credentials are used to initialise your admin panel during deployment. Unlike traditional Medusa self-hosted setups, where you manually configure database URLs, Redis endpoints, worker modes, CORS, backend secrets, and SSL, Kuberns handles the infrastructure and deployment configuration. You provide the secure values needed by the template, such as the admin credentials used to access your store dashboard. ### Step 4: Click Deploy After connecting your repository and adding the two required variables, click Deploy. ![Click Deploy to get your medusa live without manual configuration](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/medusa-deploying.png) Behind the scenes, the Kuberns agent: * Builds the Medusa backend container * Configures the production runtime * Prepares service orchestration * Injects environment variables securely * Enables HTTPS automatically * Launches your backend in production mode You do not configure PostgreSQL or Redis manually. You do not wire up background workers. You do not manage CORS, reverse proxies, or SSL certificates. When deployment completes, your Medusa backend is live and accessible via a secure URL. You can log in immediately using the admin credentials you provided. ![Medusa deployed on kuberns with one click](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/medusa-deployed-on-kuberns.png) > Instead of offering generic hosting, Kuberns uses agentic AI for deployment designed to understand application structure. When you deploy Medusa, the system prepares the correct runtime, configures service orchestration properly, injects environment variables securely, and launches the backend in a production-ready state. ## Deploy Medusa on Kuberns Today If you are building with Medusa, you likely chose it because you want full control over your e-commerce backend. You want flexibility, customisation, and ownership. What you probably did not sign up for is managing Redis instances, debugging container builds, configuring reverse proxies, or worrying about worker processes in production. With [Kuberns](https://kuberns.com/), you keep the advantages of a Medusa self-hosted backend while removing the infrastructure burden. No manual server setup. No Docker orchestration headaches. No PostgreSQL or Redis wiring. No CORS or SSL configuration. Just a production-ready Medusa backend running in minutes. If you are evaluating the best way to deploy Medusa without increasing operational complexity or hidden hosting overhead, this is the easiest path forward. [Deploy Medusa on Kuberns and launch your e-commerce backend with agentic AI for deployment.](https://kuberns.com/deploy/medusa-js) Deploy Medusa on Kuberns ## FAQs on Medusa JS ### What is the best way to deploy Medusa in production? The best way to deploy Medusa in production is to use Kuberns, an agentic AI platform for deployment that handles runtime configuration, HTTPS, environment management, and backend orchestration automatically. You choose the Medusa template, connect the repository, provide secure environment variables, and deploy. ### Where should I host Medusa? Medusa can be hosted on AWS, DigitalOcean, Railway, Render, or other cloud providers. If you want to deploy Medusa without manually configuring databases, Redis, CORS, SSL, and workers, using [Kuberns](https://kuberns.com/deploy/medusa-js) keeps the setup much simpler. ### Is there a one-click way to deploy Medusa? Yes. Kuberns provides [one-click Medusa deployment](https://kuberns.com/deploy/medusa-js) where you select the template, connect or fork the repository, add secure environment variables such as `MEDUSA_ADMIN_EMAIL` and `MEDUSA_ADMIN_PASSWORD`, and deploy without configuring servers manually. ### How long does it take to deploy Medusa? Manual deployments using VPS or Docker can take anywhere from 30 minutes to several hours, depending on configuration. With Kuberns agentic AI for deployment, Medusa can be live in minutes after you provide the required secure environment variables. ### What does Medusa need for production hosting? A production Medusa setup needs a Node.js runtime, PostgreSQL, Redis, server and worker handling, secure environment variables, HTTPS, and access to the Medusa Admin at `/app`. Kuberns handles the infrastructure configuration for open-source Medusa deployments. ### Do I need to configure PostgreSQL and Redis manually on Kuberns? No. On Kuberns, you do not manually configure PostgreSQL, Redis, CORS, SSL, or worker infrastructure for the Medusa template. You provide the secure environment variables requested by the template, and Kuberns handles the deployment setup. ### Where is the Medusa admin dashboard after deployment? After a successful Medusa deployment, the admin dashboard is available at the deployed backend URL followed by `/app`. You can log in with the secure admin email and password provided during setup. --- - [More Open Source articles](https://kuberns.com/blogs/category/open-source/1/) - [All articles](https://kuberns.com/blogs/)