Which ERPNext install route fits your production team
If you are an operations or platform lead choosing how to host ERPNext in production, the Frappe documentation recommends Docker images for production sites and does not recommend installing on bare-metal servers. A bench installation remains acceptable for development, where the team needs direct access to the code, custom app work and fast iteration. For production, the Docker route fits teams that want a repeatable image, a compose.yaml base that already wires MariaDB, Redis, background workers, the scheduler, Socket.io and Nginx, and a build pipeline for custom apps. The condition is that someone on the team can own image builds, volume backups and version pinning, because those tasks move to you once the stack is containerized.
A bench route fits a team that already runs Linux servers, has Python and Node.js operators comfortable with the Frappe toolchain, and accepts that it is off the path the project recommends for production. sudo bench setup production automates Supervisor and Nginx configuration on a single server, which is useful for a small internal deployment. Before choosing it, confirm with your own security and operations staff how you will handle host patching, process supervision and reproducible rebuilds, since the Frappe guidance does not cover those on your behalf. Also confirm that your planned Python and MariaDB versions match the Frappe version you intend to run.
Treat the pwd.yml file as an evaluation tool only. The frappe_docker README describes it as a disposable demo for short-lived use, and it cannot install custom apps, so a team that plans custom work needs to move to a production image build before going further. Whichever route you pick, ask your implementation partner for a written scope covering the build pipeline, backup and restore tests, and the upgrade path for each supported ERPNext version, as set out in the Frappe setup production guide.
Docker and bench side by side for ERPNext
This table compares the frappe_docker Compose route with a bench installation on a Linux server across the factors that shape a production ERPNext deployment. Read the rows where the Frappe project's recommendation is stated first, then check the rows marked for confirmation against your own environment and a written quote from Frappe or a partner.
| Factor | frappe_docker (Compose and images) | Bench installation on Linux |
|---|---|---|
| Vendor recommendation for production | The Frappe setup production guide recommends Docker images for production sites, and the frappe_docker README names compose.yaml as the base for production setups. | The Frappe setup production guide says the project does not recommend installing on bare metal servers, so bench is not the recommended production route. |
| Production setup | Compose services cover MariaDB, Redis, background workers, the scheduler, Socket.io and Nginx, as described in the frappe_docker repository. | Running sudo bench setup production automates the steps, with Supervisor keeping Frappe processes running and Nginx serving static files and proxying other requests. |
| Demo versus production | pwd.yml is a disposable demo for short-lived evaluation only and must not be used as a production base. | Bench is documented for development and multi-site management, and the README says either method is acceptable for development. |
| Custom apps | The pwd.yml demo cannot install custom apps, so custom apps require building a custom app image. | Custom apps are installed through bench on the server, so the team must manage app code, dependencies and versions on the host itself. |
| Upgrade path | Upgrades mean building or pulling new images and redeploying Compose services. Confirm the exact upgrade steps and rollback method with Frappe documentation for your target version. | Upgrades run through bench commands on the host. Confirm the sequence, backup steps and downtime for your version with Frappe documentation before scheduling. |
| Licensing | ERPNext is GPL-3.0 and self-hosting is free according to the ERPNext pricing page, so the container route carries no license fee for the software itself. | The same GPL-3.0 licensing and free self-hosting apply to a bench install. Any paid hosting, support or partner work is a separate cost. |
| Skills required | Docker, Compose, image builds, container networking and volume management, plus Frappe application knowledge for custom apps. | Linux administration, Python and Node.js runtime management, Supervisor and Nginx configuration, plus Frappe application knowledge. |
| What remains with the client | Host OS, Docker engine, image registry, backups of volumes and the database, monitoring, TLS and access control. Confirm whether Frappe or your partner covers any of these. | Host OS, runtime versions, Supervisor and Nginx, database and Redis operations, backups, monitoring and security patching. Confirm the support scope in writing. |
How the frappe_docker production setup is structured
The `compose.yaml` file is the base for a production setup, while `pwd.yml` is a single-file demo meant only for short-lived evaluation. The frappe_docker project builds its production path around the first file, so a team planning a long-lived ERPNext environment should start from compose.yaml and treat pwd.yml as a way to try the software, not a foundation to grow. The two files answer different questions, and mixing them up is the most common way an evaluation quietly becomes a production system.
The production stack is split into separate services: MariaDB for the database, Redis for caching and queues, background workers that run long jobs, a scheduler for timed tasks, Socket.io for real-time updates, and Nginx to serve static files and route requests. Each service can be sized, monitored, backed up and restored on its own terms, which is why your platform team should review the service list against its own operating model before committing. Confirm with the frappe_docker documentation which volumes hold database and site data, since those define your backup scope.
Custom apps are the point where the demo and production routes split. The frappe_docker README states that `pwd.yml` cannot install custom apps, and it names building custom app images as the documented route for adding them. Any in-house code, third-party app or industry extension therefore has to be baked into an image your team builds, versions and stores. Plan for that image pipeline early, including who owns the build, how images are tagged for each ERPNext release, and how a failed upgrade rolls back to the previous image.
What sudo bench setup production does on a Linux server
The bare-metal route turns a bench install into a supervised, web-served production site, but the team running it owns the operating system, runtimes, patching and backups for the life of the deployment. The sequence below shows where that work sits and how to confirm each step finished.
Prepare the Linux host and runtimes
The systems team installs a supported Linux distribution, Python, Node.js, MariaDB, Redis and the other packages the Frappe installation documentation lists for the release you plan to run. Version requirements differ between Frappe releases, so confirm them against the Frappe installation documentation for your chosen version before installing anything. Done means the required versions report correctly from the command line on the target server, and the host is patched and reachable only where your network policy allows.
Install bench and initialize a bench directory
An administrator installs the bench command-line utility and initializes a bench directory, which holds the Frappe Framework code, configuration and site folders. Bench is the tool that manages every later step, so its installation runs under a named service account that your team controls. Done means the bench directory exists and the bench version command returns without errors.
Install ERPNext and create a site
The team fetches the ERPNext app into the bench, then creates a site with its own database and administrator credentials. Each site is a separate database and file set, so the initial admin password and database root credentials should go into your secrets manager at this point. Done means the site is listed by the bench site listing command and the app is installed on it.
Run sudo bench setup production
The administrator runs sudo bench setup production against the bench, which automates the production steps for the host. The command configures Supervisor to keep the Frappe processes running, including the web workers, background workers and scheduler, and configures Nginx to serve static files and proxy other requests to the application. Done means the command completes without errors and the generated Supervisor and Nginx configuration files are present on the host.
Verify Supervisor and Nginx serve the site
The operator checks that the Supervisor-managed processes are running and that Nginx answers on the expected address and serves the site over the protocol your policy requires. Confirm that the site's hostname resolves internally and that a login page loads from a client machine. Done means the processes stay up after a restart of the host and the site responds through Nginx, not only on the internal development port.
Add TLS, firewall rules and access controls
Your security or platform team issues the TLS certificate, opens only the required ports in the host and network firewalls, and sets access rules for the admin interface and database. The setup command does not decide these for you, so record each decision in your configuration baseline. Done means an external scan shows only the intended ports open and the certificate chain validates for the site hostname.
Schedule backups and patching ownership
The operations team owns scheduled backups of the database and site files, tested restores, and the patch cadence for the operating system, runtimes and Frappe releases. Assign an owner for each item and write down how often patches are applied and where backups are stored. Done means a restore has been rehearsed on a separate host and the owner list is signed off by the service owner.
Custom apps, server scripts and images in each route
Customization is where the Docker and bench routes diverge most. The choice of route determines how custom apps get installed, whether Server Scripts can run, and what your team must rebuild and test on every upgrade. Check these items against your extension plan before you pick an installation method.
Building custom app images
In the Docker route, custom apps ship inside an image you build from the frappe_docker setup, so the app code, its dependencies and the ERPNext version are fixed together. Your team owns the build pipeline, the image registry and the rebuild that follows every ERPNext upgrade. Confirm that your CI can build, tag and roll back these images before committing to custom apps. This route suits teams that already run container pipelines.
Installing custom apps on a bench
On a bench, custom apps are fetched and installed into the bench directory, then installed on each site. This is the more direct route for developers who work on the server, but it also means your team manages app versions, dependency changes and site migrations by hand. Because the Frappe project does not recommend bare metal for production, treat a bench-hosted custom app as a development or controlled exception and document who maintains it.
The pwd.yml demo limitation
The single-file pwd.yml demo cannot install custom apps. Teams that test an app idea on it will hit a dead end, so do not plan a proof of concept around it. The frappe_docker project positions pwd.yml as disposable and intended for short-lived evaluation only. Move to a custom app image built on the production compose.yaml base before any customization work starts.
Server Scripts disabled by default
Server Scripts run Python on document events or as API endpoints. From version 15 they are disabled by default and must be enabled with the server_script_enabled setting. Enabling it is a deliberate security decision, because any user with the right permission can run server-side Python. Record who may enable it, how changes are reviewed, and where the setting lives in each environment, whichever route you choose.
Frappe Cloud shared benches block Server Scripts
Frappe Cloud public shared benches do not allow Server Scripts. A customization that relies on them will not run on a shared plan, so the hosting choice constrains the design. Confirm the bench type you need before you write the first script. If your extensions depend on Server Scripts, a dedicated bench or a self-hosted route is the practical way to keep them. This is a question to settle with Frappe, not assume.
Data Import batch size
The Data Import tool loads CSV or Excel files and public Google Sheets, including child table rows. The documentation advises importing only a few thousand records at a time. Plan migration batches and validation checks in either route, because the limit applies to the tool rather than to the installation method. Ask your implementation partner to include batch sizing and reconciliation in the migration scope.
Which route fits which team situation
A team that already runs containers in production usually finds the official route, the frappe_docker images with the compose.yaml base, the closest match to how it already works. The Frappe project recommends Docker images for production sites rather than bare metal, so this team follows the project's stated direction. The route makes sense when the team already has image registries, CI pipelines and monitoring for other services.
- Image pipeline: Build, tag and scan the images in your own registry, and pin the ERPNext version you deploy.
- Compose configuration: Own the services for MariaDB, Redis, workers, the scheduler, Socket.io and Nginx, including volumes and secrets.
- Backups: Define and test backups for the database and the site files, because the containers themselves are disposable.
- Upgrade process: Plan version moves through new images and migrations, and check release notes before each change.
- Host operations: Patch the Docker host and keep the container runtime current.
Before committing, confirm with the frappe_docker documentation which Compose file and image tags match your target ERPNext version.
A team strong in Linux administration but new to containers can use a bench installation on a Linux server. Bench is the command-line utility that installs, updates and manages Frappe sites on Unix-like systems, and sudo bench setup production automates the production steps, with Supervisor keeping processes running and Nginx serving static files. This route matches a team that is comfortable with system services, package management and manual troubleshooting.
- Server build: Provision the OS, Python, Node.js, MariaDB and Redis to the versions the Frappe installation documentation lists for your release.
- Process supervision: Monitor Supervisor-managed workers and the scheduler, and restart them after failures.
- Web tier: Maintain Nginx configuration, TLS certificates and reverse proxy rules.
- Upgrades and patches: Run bench updates and OS patches on a schedule you define.
- Recovery: Document restore steps for each site.
The project does not recommend bare metal for production, so ask DeployOpen or your own architects to document the risk and the support position before go-live.
For developers building apps, testing configuration or evaluating ERPNext, either route works. The bench README states that both methods are acceptable for development, and bench is the usual choice for developers who edit app code and run tests. The pwd.yml demo file is a different case: it is a disposable setup for short-lived evaluation only, and it cannot install custom apps.
- Demo use: Use
pwd.ymlonly for a quick look at the product with no data you need to keep. - Developer workflow: Use bench for hot reloading, app development and branch testing.
- Data handling: Load sample data with the Data Import tool in small batches, since the documentation advises a few thousand records at a time.
- Refresh policy: Recreate test environments from scripts rather than copying production data unless your data rules allow it.
- Isolation: Keep test hosts off production networks and secrets.
Do not promote a demo or dev setup into production. Confirm with your security team how test data containing personal information is handled.
A team that must ship custom Frappe apps needs an image-based route, because the frappe_docker README says the pwd.yml demo cannot install custom apps and points to building custom app images instead. This route makes sense when several environments must run identical code and the team wants app versions tied to image tags. It shifts work from the server to the build pipeline.
- Image build: Create a custom image that includes your apps, and version it alongside the ERPNext release it targets.
- Dependency checks: Test each app against the ERPNext version you intend to run, since app compatibility follows the release line.
- Server Scripts: If your apps depend on Server Scripts, note that they are disabled by default from version 15 and must be enabled with
server_script_enabled, and Frappe Cloud public shared benches do not allow them. - Code review: Own security review for every app, because custom code runs with platform privileges.
- Rollback: Keep prior app images so you can revert a failed release.
Before you build, confirm the app's compatibility with your target release and your own review process.
Upgrades, backups, monitoring and skills for each route
This table compares how each route handles upgrades, backups, monitoring, rollback, troubleshooting and staffing for ERPNext. Read it as an operating model: the route you pick sets who patches containers or hosts, who watches the processes, and which skills your team must keep in-house. The main takeaway is that the Frappe project recommends Docker for production, so a bare-metal bench carries more of the operating burden on your side.
| Operating area | Docker route (frappe_docker) | Bench route (bare-metal Linux) |
|---|---|---|
| Production recommendation | The Frappe project recommends Docker images for production sites | The project does not recommend bare-metal servers for production, so this route needs a documented reason |
| Upgrade path | Move to new image tags built from supported releases, then run migrations inside the stack | Update the bench and apps on the host, then migrate each site; confirm the exact order in Frappe docs |
| Version windows to plan around | Keep to a supported line: v16 is supported until the end of 2029, v15 until the end of 2027 | Same supported-version windows apply; a host upgrade adds OS and runtime changes on top |
| Patch cadence to track | Track minor releases such as v16.51.1 (October 15, 2026) and v15.123.0 (October 14, 2026) and rebuild images | Track the same ERPNext minor releases and pull them onto the bench manually |
| Backups | Back up the database, site files and volumes that the Compose services use; test restores against your own runbook | Back up the MariaDB database and site files on the host; confirm backup and restore steps with Frappe documentation and your own tests |
| Rollback | Redeploy the previous image tag, but confirm whether database migrations can be reversed before relying on it | Restore from backup or reinstall the previous app version; no image rollback exists, so the backup is the rollback |
| Monitoring | Watch the containers for MariaDB, Redis, workers, scheduler, Socket.io and Nginx, plus your host and volumes | Watch Supervisor-managed processes and Nginx on the host, plus MariaDB, Redis and disk |
| Troubleshooting skills | Container runtime, Compose, volume and networking skills, plus ERPNext and Frappe internals | Linux administration, Supervisor, Nginx, Python and bench command-line skills, plus ERPNext and Frappe internals |
| Staffing driver | Your team needs container operations; a platform or DevOps engineer usually owns it | Your team needs Linux and service administration; the same person often carries backups and patching |
What drives the cost of each ERPNext install route
The software itself costs nothing to self-host. The ERPNext pricing page states that self-hosting ERPNext is free, so the budget for either route is made up of people and infrastructure. Your staff or a partner's team is paid to build and harden the host, run the bench or Compose stack, configure accounting and inventory, and test every upgrade before it reaches production. Infrastructure is paid monthly or yearly: virtual machines or bare metal, storage for MariaDB and backups, and any load balancer or monitoring service you add. Both routes carry these costs, but the Docker route shifts more of the host work into image builds and Compose files, while the bench route puts Supervisor, Nginx and the server operating system on your team's plate.
Custom apps and upgrades are the costs that grow over time. Each custom app adds development, code review and a test cycle for every ERPNext minor release, and on the Docker route it also adds an image build pipeline. The frappe_docker README says the pwd.yml demo cannot install custom apps, so any custom work starts with building your own image. Ask a partner to price custom app work separately from platform setup, and to state who maintains the custom code after go-live. Confirm the upgrade process with the vendor's support versions page before you commit, since version 15 and version 16 have different support windows.
Frappe Cloud is a comparison point, not a default. Frappe Cloud shared site hosting starts at 5 US dollars per month, shared servers start at 20 US dollars per month and dedicated servers start at 125 US dollars per month, according to the ERPNext pricing page. Those figures show what managed hosting costs at the entry level, but they do not include your implementation, custom app work or the staff time you would still need. A quote for self-hosting follows from a written scope that lists hosts, components, custom apps, backup targets, upgrade testing and support hours, so ask every bidder to price those items separately and to name what recurs each month and what is paid once.
Questions buyers ask before choosing a route
Is Docker required to run ERPNext in production?
No, Docker is not required by the software, but it is the route the Frappe project recommends for production. The bench README recommends the Docker installation for production, and the Frappe production setup guide states that the project does not recommend installing on bare metal servers and recommends Docker images for production sites instead. A bench installation can still run production if your team accepts that it is outside the project's recommended path. Confirm with your own security and operations leads which route they can support over the life of the system.
Is a bench installation supported for production use?
A bench installation can be set up for production with the command sudo bench setup production, which configures Supervisor to keep Frappe processes running and Nginx to serve static files and proxy other requests. The Frappe project, however, does not recommend bare metal installs for production and points to Docker images instead. Choose this route only if you have Linux administration skills in-house, can own patching of the operating system, database and Redis, and accept that you are not following the project's preferred production path.
Can the pwd.yml demo file run a production ERPNext site?
No. The pwd.yml file in frappe_docker is a disposable demo intended for short-lived evaluation only, and it is not the base for production. The production base is the compose.yaml file, which defines services for MariaDB, Redis, background workers, the scheduler, Socket.io and Nginx. Use pwd.yml to try the product, then move to a production configuration with persistent storage, backups and your own domain and certificates before loading real business data.
How do custom apps get added to a Docker-based ERPNext?
The frappe_docker README states that the pwd.yml demo cannot install custom apps. For Docker, the route is to build a custom app image that includes your app alongside ERPNext, then deploy that image with your Compose configuration. On a bench installation, custom apps are added with bench commands to the bench directory. In both cases, plan for version pinning against the ERPNext release you run, a repeatable build process, and testing before each upgrade, since custom code is what most often breaks during upgrades.
How long does it take to move between Docker and bench?
The supplied facts do not give a migration duration, so confirm it for your own environment rather than planning from a guess. The main variables are the number of sites, database size, the number and complexity of custom apps, whether you keep the same ERPNext version, and how much of the server configuration needs rebuilding. Ask any implementation partner for a written method, a rehearsal on a copy of production data, and a rollback plan before agreeing on a timeline.
Can our own team run ERPNext without outside help?
Possibly, depending on your skills. Running ERPNext needs people who can manage Linux or containers, MariaDB, Redis, backups, TLS certificates, upgrades between supported versions, and custom app code. The Frappe supported versions policy means you must stay on a listed version to remain within support, and ERPNext v15 is planned to be supported until the end of 2027 and v16 until the end of 2029. Assess whether you have staff for these tasks on a recurring basis, not just at go-live.
What does a fixed-scope DeployOpen engagement cover for ERPNext?
DeployOpen plans, implements, customizes, integrates, hardens, backs up, upgrades, documents and supports self-hosted open-source platforms inside your own infrastructure. For ERPNext, a fixed-scope engagement can cover choosing between the Docker and bench routes, building the production configuration, adding custom apps, hardening, backup design and documentation. Scope, deliverables and timelines are agreed in writing before work starts, and a quote follows from that written scope. Ongoing support, upgrades and testing are available as retainers.
What drives the cost of running ERPNext yourself?
The software itself is free, since the ERPNext pricing page states that self-hosting ERPNext is free. The recurring cost is infrastructure and people. Your servers or cloud accounts, backup storage, monitoring, and staff time for upgrades and custom app maintenance are paid by you. Docker can lower the effort of rebuilding environments, while bench moves more of the server administration to your team. Ask any provider for a quote that separates one-time setup from recurring support, upgrades and testing.
How hard it is to switch routes after go-live
Switching from Docker to bench, or back, after go-live is a migration project, not a configuration change. The data lives in a MariaDB database and a site directory, and the two routes arrange those files differently. Moving a site means exporting it from the source environment, restoring it into the target, reattaching files and private storage, and confirming that every site and its backups still line up. Custom apps add a second track. On the Docker route they must be packaged into a custom image, because the demo pwd.yml cannot install them at all, and on the bench route they must be installed into the bench and kept at matching versions. Each app therefore has to be rebuilt and tested on the target before the data moves.
Plan for the network side as well. DNS records, TLS certificates, and the reverse proxy configuration all change when the entry point moves from one stack to the other, and the Nginx layer that serves static files and proxies requests on a bench production setup is not the same as the proxy layer in the Compose stack. Background workers, the scheduler and Socket.io also need to start and point at the right Redis and database services before users return. Ask Frappe through its documentation and support channels which export and restore steps are supported for your ERPNext and Frappe version, and whether a route change is covered by the upgrade path you intend to use.
Rehearse the full move in a non-production environment with a recent copy of production data, custom apps and integrations included, and time each step against the cutover window you actually have. Check that scheduled jobs, email, login integrations such as LDAP or social login, and document permissions behave the same afterward. Treat the rehearsal output as the basis for the cutover runbook and rollback plan, and keep the original environment intact until users have confirmed their work.
How DeployOpen scopes and runs ERPNext deployments
DeployOpen plans, implements, hardens, backs up, upgrades, documents and supports self-hosted open-source platforms inside the client's own infrastructure, including ERPNext. For this decision, we start from the written scope, confirm which installation route fits your hosting and team skills, and deliver the setup with documentation your own staff can operate.
How we scope
- Most engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts.
- The written scope states which ERPNext route applies, the target servers or cloud accounts, and the custom apps to be included.
- We confirm your ERPNext and Frappe version targets, database and cache services, and who owns upgrades after handover.
- A quote follows from the written scope, so the scope document should list the environments, integrations and testing you expect.
How we build
- For a Docker route, we build the Compose configuration, images and any custom app images inside your environment.
- For a bench route, we set up the production steps, process supervision and web server configuration on your Linux hosts.
- We configure backups, access controls and logging to match the scope, then test restore procedures before go-live.
- Where custom apps are needed, we plan how they are packaged, tested and rebuilt during each upgrade cycle.
How we hand over
- Handover includes documentation of the installed architecture, the commands and configuration your team will use.
- We document the upgrade path, rollback steps and backup verification so operators can repeat them without us.
- Evidence for compliance assessments, such as configuration records and access settings, is prepared where the scope requires it.
- DeployOpen prepares systems and evidence for assessments but does not issue audit reports or certifications.
How we support
- Ongoing support, upgrades and continuous testing are available as retainers, agreed separately from the initial scope.
- Security testing of the deployed ERPNext instance and its APIs can be scoped as a separate engagement.
- Before choosing a route, ask us to confirm which support windows and Frappe version policies apply to your target release.

