# How to Deploy Applications Built With Cursor in 2026 > Best way to deploy a website built with Cursor is using Kuberns. Review the detected stack, enable HTTPS, connect a custom domain, and troubleshoot with MCP. - **Author**: charan-achari - **Published**: 2025-12-12 - **Modified**: 2026-10-07 - **Category**: Deployment Guides - **URL**: https://kuberns.com/blogs/deploy-cursor-website-on-kuberns/ --- To deploy a website built in Cursor, push the project to GitHub, connect that repository to Kuberns, review the detected setup, provide any required application values, and start the deployment. Kuberns then builds the application and provides a live HTTPS URL without requiring you to assemble a deployment pipeline. The code determines the hosting requirements, not the editor. A static landing page, a Next.js application with server routes, and a Node.js API built in Cursor need different production resources. Kuberns is an Agentic AI platform for deployment that inspects the repository and prepares the build and infrastructure for the detected application. This guide shows how to prepare the project in Cursor, move it to GitHub, deploy it with Kuberns, connect a custom domain, and use the Kuberns MCP connection when you want deployment context available inside Cursor. **TL;DR:** - Run a production-readiness check in Cursor and keep secrets out of GitHub. - Push the complete project to a GitHub repository. - Connect the repository and production branch to [Kuberns](https://kuberns.com/). - Review the detected configuration and provide only values that cannot be inferred from code. - Deploy, check the logs, and verify the live HTTPS application. - Optionally connect Kuberns to Cursor through MCP for supported deployment inspection and troubleshooting inside Cursor. ## What to Check Before Deploying a Cursor-Built Website Start by asking Cursor to inspect the repository rather than assuming that a working local preview is production-ready. A local development server can hide missing dependencies, hardcoded local URLs, uncommitted files, and configuration that fails in a clean build environment. Use a prompt such as: ```text Review this project for production deployment. Run the production build, identify the runtime and start command, list the required environment-variable names, check for hardcoded localhost URLs, confirm that secret values are not committed, and report anything that could fail outside my local machine. Do not expose or print secret values. ``` Before pushing the project, confirm that: - The production build completes successfully. - The correct dependency and lock files are committed. - Required environment-variable names are documented in a safe `.env.example` file when appropriate. - `.env` files, API keys, tokens, and database passwords are excluded from Git. - Browser code does not call a backend through `localhost` in production. - The repository contains the frontend, backend, configuration, and migrations the application requires. | Cursor-built project | What to confirm before deployment | |---|---| | Static HTML, CSS, and JavaScript | Entry file, asset paths, and client-side routes | | React, Vue, or Vite frontend | Install command, production build, output directory, and API URL | | Next.js, Remix, or another full-stack framework | Server runtime, environment variables, server routes, and database access | | Node.js, Python, Go, or another API | Start command, listening port, health endpoint, and CORS rules | | App with PostgreSQL or another service | Connection variables, migrations, and persistent data requirements | | Worker or scheduled process | Process command, queue connection, retries, and logs | If you are moving a broader AI-built project from prototype to production, the guide to [deploying an app after vibe coding](https://kuberns.com/blogs/after-vibe-coding-deploy-your-app/) explains how to review its architecture and production dependencies. ## How to Deploy a Cursor Website From GitHub With Kuberns The deployment path is Cursor → GitHub → Kuberns. Cursor remains the development environment, GitHub becomes the versioned source of truth, and Kuberns handles the deployment layer. ### Step 1: Push the Cursor project to GitHub Open the project in Cursor, review the changed files, commit the complete working version, and push it to a GitHub repository. You can use Cursor's Source Control interface or its terminal. ![Connect a Cursor project to GitHub](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/connect-cursor-to-github.png) Do not commit `.env` files or credentials. If the project requires environment variables, keep the values ready for the deployment workflow and commit only safe names or placeholders. ### Step 2: Connect the GitHub repository to Kuberns Sign in to the [Kuberns dashboard](https://dashboard.kuberns.com/) with GitHub, choose the repository containing the Cursor project, and select the production branch. ![Connect a GitHub repository to Kuberns](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/kuberns-registration.png) Kuberns inspects the repository and detects the framework, runtime, dependency files, build requirements, and infrastructure the application needs. This removes the need to start by writing a Dockerfile, provisioning a server, or assembling a CI/CD pipeline. ### Step 3: Review the detected setup Review the application root, runtime, build command, start command, port, and environment-variable names proposed during the setup. The repository should remain the source of truth, but you should confirm that the detected settings match the application you intended to deploy. ![Kuberns detecting and preparing the application deployment](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/agent-deployment-process.png) If the application depends on a value that cannot be discovered from code, such as a third-party API key, provide it through the deployment flow. Kuberns prepares the deployment infrastructure, while you supply the application-specific secrets the code requires. ### Step 4: Deploy the application Start the deployment after reviewing the configuration. Kuberns pulls the selected revision, installs dependencies, builds the application, and starts the production process. Follow the build logs instead of assuming a successful build also means the running application is healthy. ![Kuberns dashboard showing application deployment details](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/all-in-one-dashboard.png) When the deployment completes, open the generated HTTPS URL and test the application before sharing it with users. ### Step 5: Verify the live website Check the parts of the application that can behave differently outside local development: - Open every important route and refresh a nested route directly. - Test forms, authentication, API calls, file uploads, and database writes. - Confirm that the browser is not calling `localhost` or a development service. - Review build and runtime logs for recurring errors. - Verify redirects, CORS behavior, and secure cookies where applicable. - Push a small follow-up change and confirm that the expected branch creates a new deployment. For a deeper explanation of deployments triggered by later commits, follow the guide to [set up GitHub auto-deploy](https://kuberns.com/blogs/how-to-auto-deploy-your-apps-from-github-in-one-click/). ## Connect Cursor to Kuberns Through MCP After the application is connected to Kuberns, you can optionally add the Kuberns remote MCP server to Cursor. This gives Cursor access to the Kuberns tools that are available to and authorized for your account. The practical benefit is deployment context inside the editor. Cursor already understands the repository, and the Kuberns connection can provide supported information such as deployment status, build history, build and runtime logs, and non-secret configuration. When a build fails, Cursor can compare that evidence with the files and dependencies in the repository without requiring you to copy every log between tools. MCP does not automatically grant every deployment action. The live Kuberns tool inventory and the permissions approved during authentication determine what Cursor can inspect or change. Follow the complete steps to [connect Cursor to Kuberns through MCP](https://kuberns.com/blogs/connect-cursor-to-kuberns/), authenticate the connection, verify the available tools, and begin with a read-only deployment-status request. ## How Kuberns Handles the Production Setup Kuberns turns the GitHub repository into a managed deployment instead of asking you to configure the underlying cloud resources manually. ![Kuberns Agentic AI platform for deploying Cursor-built applications](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/kuberns-home-page-new.png) Depending on the detected application and the values it requires, the deployment workflow can cover: - Framework and runtime detection - Build and production process configuration - Environment-variable handling - Managed HTTPS URL - Build and runtime logs - Deployment history - Later deployments from the selected GitHub branch - Databases or worker processes when the application requires and supports them Kuberns plans start at $7, with a Trial Option available. Bundle packs can provide additional savings depending on the deployment requirements. ### Add a custom domain and HTTPS The custom domain is configured on the deployed project, not inside Cursor. 1. Open the deployed project in Kuberns. 2. Add the domain you want to use. 3. Copy the DNS record shown by Kuberns. 4. Add that record at your DNS provider. 5. Wait for DNS to resolve and verify the HTTPS version of the domain. ![Add a custom domain to a Kuberns deployment](https://kuberns-blogs-media.s3.ap-south-1.amazonaws.com/add-custom-domain.png) Kuberns provisions HTTPS for the connected domain, so you do not need to upload or renew certificate files manually. ## How to Diagnose a Failed Cursor Deployment A failed deployment usually means the production environment exposed an assumption that local development did not. Start with the first meaningful error in the build or runtime logs rather than the final generic failure message. | Symptom | What to inspect | |---|---| | Dependency installation fails | Package manifest, lockfile, runtime version, and private package access | | Build command fails | Missing variables, unresolved imports, case-sensitive paths, and framework configuration | | App starts and then exits | Production start command, listening address, port, and required services | | Frontend loads but API calls fail | Production API URL, CORS, authentication cookies, and backend availability | | Direct route returns 404 | SPA fallback or framework routing configuration | | Database feature fails | Connection variable, network access, migrations, and database permissions | Copy the relevant error into Cursor and ask it to trace the failure to the responsible file or configuration. If Kuberns MCP is connected, use the supported tools to retrieve deployment evidence inside Cursor before asking the agent to propose a fix. Review every suggested change, push the correction to GitHub, and verify the new deployment. ## Conclusion Cursor helps you build and change the application, but it does not host the resulting website. The reliable production path is to verify the project, push it to GitHub, connect the repository to Kuberns, review the detected setup, and test the deployed application through its live HTTPS URL. Kuberns provides the deployment layer without requiring you to begin with servers, Docker configuration, or a manually assembled pipeline. Once the application is live, the optional Kuberns MCP connection gives Cursor supported deployment context for faster inspection and troubleshooting from the editor. Deploy a Cursor-built application with Kuberns ## Frequently Asked Questions ### Can I deploy a website directly from Cursor? Cursor is a code editor and does not host the website itself. Push the project from Cursor to GitHub, connect that repository to Kuberns, and start the deployment after reviewing the detected configuration and required application values. ### Do I need to create a deployment pipeline for a Cursor project? No manual deployment pipeline is required for the workflow in this guide. Kuberns connects to the selected GitHub branch and can build and deploy later repository updates through the same workflow. ### How do I set up a custom domain and HTTPS for a Cursor app? Add the domain to the deployed project in Kuberns, copy the DNS record shown by Kuberns to your DNS provider, and wait for the record to resolve. Kuberns then provisions HTTPS for the connected domain without requiring you to manage certificate files manually. ### What kinds of Cursor projects can I deploy on Kuberns? The hosting requirement depends on the code Cursor produced, not the editor itself. Kuberns can deploy supported static frontends, full-stack frameworks, APIs, and applications with databases or worker processes after it inspects the repository and confirms the required runtime configuration. ### Should I commit my Cursor project's .env file to GitHub? No. Keep `.env` and secret values out of GitHub. Commit an `.env.example` containing safe variable names when useful, then provide the real values through the deployment workflow. ### What can Cursor do after I connect it to Kuberns through MCP? Cursor can use the Kuberns tools available to your account to inspect supported deployment information such as status, build history, logs, and non-secret configuration. The live tool inventory and approved permissions determine the actions available. --- - [More Deployment Guides articles](https://kuberns.com/blogs/category/deployment-guides/1/) - [All articles](https://kuberns.com/blogs/)