Applying ERPNext minor updates with bench update

A practical guide to keeping ERPNext version 15 or 16 sites current with frequent minor releases using bench update, with backups, app exclusions and a test site before production.

On this page

How to apply ERPNext minor updates with bench update safely

Minor updates are routine work on a self-hosted ERPNext site, and they are the part of ownership you should plan for every month, not once a year. A minor release keeps your site on the same major version, so a site on v16 stays on v16 and a site on v15 stays on v15. Both supported majors ship frequently: the ERPNext releases page lists v16.51.1 released on October 15, 2026 and v15.123.0 released on October 14, 2026. The major upgrade path, which changes the version itself and often splits apps, is covered on separate pages and should not be mixed into a routine patch cycle.

The command that applies a minor release is bench update. Run without flags in your bench directory, it backs up the site, pulls the new code, sets up requirements, builds assets, runs database patches and restarts the bench. Because it does several things in one step, decide before you run it which apps stay on their current versions. Use the --exclude-app option to hold back a companion app that your team has not yet tested, and confirm in the bench command reference how your bench version handles the flag. Also confirm whether your site depends on custom apps or Server Scripts, since those can break during patches even when the core apps update cleanly.

Treat every minor release as a change that needs a test site first. Clone production to a staging bench, apply the same update there, then check the workflows your finance and stock teams use daily, such as invoice submission, stock entries, payment reconciliation and the reports your auditors rely on. Confirm that the backup taken by bench update is restorable, and keep your own independent backup as well so you have a recovery point you control. Agree on who approves the production window, who can roll back, and how long the site can be unavailable, and write those answers down before the first routine update.

What changes between minor releases and what each change asks of you

This table compares the categories of change that a bench update carries into a site, the impact of each one, and the action the team should take. Read the release notes for each tag before applying it, because the categories below describe how bench update works, not what a specific release changes. The main takeaway is that code, dependencies, patches and restarts each need their own check before production.

Change categoryImpact on the siteAction for the team
Code pulled for ERPNext and companion appsbench update pulls new commits for each installed app, so behavior of forms, reports and workflows can change.Read the release notes for each tag, then test the same update on a test site before production.
Requirements and build stepsPython packages and frontend assets are reinstalled and rebuilt, which can fail on a server with a different environment.Confirm the build completes on the test site and check that the server has the packages the update expects.
Patches run during migrateDatabase patches alter schema or data, and a failed patch can leave the site partly changed.Take a backup before the update and review any patch notes that touch your customized doctypes.
Bench restartWorkers, scheduler and web processes restart, so users and background jobs are briefly interrupted.Schedule the update in a maintenance window and confirm that background jobs are idle first.
Apps excluded with exclude-appAn excluded app keeps its current code, so it can drift out of step with ERPNext after the update.Only exclude an app when its matching branch is confirmed compatible, and record every exclusion for the next update.

What bench update does when you run it without flags

Running bench update without flags in a bench directory runs a fixed sequence: it takes a backup, pulls the latest code for the bench and its installed apps, sets up Python and Node requirements, builds the frontend assets, runs the database patches for each site, and restarts the bench. The order matters. The backup comes first so that a rollback target exists before anything changes, and the patch step comes after the code and requirements are updated, because the patches are written for the new code. Each stage touches a different layer. The pull changes files in the apps directory, the requirements step changes the Python and Node environments, the build regenerates assets, and the patch step changes the database schema and data for every site on the bench. Only the last of these is hard to reverse by replacing files. Confirm the exact stage order and default behavior against the bench commands page for your bench version, since flags and defaults change between releases.

The patch stage is where the real risk sits. Patches run site by site and each one is recorded as applied once it finishes, so a patch that fails partway through can leave a site with some schema changes made, some data rewritten and the remaining patches not yet run. The code on disk is already new, so reverting the apps alone does not return the database to its old state. This is why the backup must be a full site backup that includes the database and files, and why you should check that the backup restores before you rely on it. Plan for the failure case in advance: know which site failed, who can read the bench logs, whether your team can restore the database from the backup taken in the same run, and how long a restore takes on your hardware. If you run several sites on one bench, a failure on one site still blocks the restart and the remaining sites, so decide whether you want to update a test bench first and keep production updates in a separate window.

When to update everything and when to exclude an app

Running bench update without flags is the default path when every installed app is a version you have tested against the target ERPNext release. The command backs up the site, pulls the code for every app, sets up requirements, builds assets, runs patches and restarts the bench, so the whole stack moves as one unit. This keeps ERPNext, Frappe and your companion apps on matching branches, which is the main reason to update everything at once.

  • Scope of the run: Every app in the bench is pulled and patched, including official apps such as HR or India Compliance if they are installed.
  • Backup first: The command takes a backup before it changes code, but a copy you hold outside the server is still required for recovery.
  • Patches run on every site: Each site in the bench runs its pending patches, so a multi-site bench needs its sites checked together.
  • Restart window: The bench restarts at the end, so plan a short service interruption for users.
  • Version check: Confirm the installed branches match the release line you intend to stay on before you start.

Before running the full update on production, confirm the same sequence succeeds on a test site with the same apps and customizations.

Backups, customization inventory and a test site before production

A minor update is small in version terms but still runs migrations against your data, so the work before it matters as much as the command. The cards below cover what to protect, what to inventory, and where to rehearse. Each one is a check you can run on your own site before the update window opens.

Current backup and restore test

Take a fresh backup with bench --site yoursite backup --with-files before every update, and confirm the file exists and is recent. A backup you have never restored is only a hope, so restore it to a scratch site and open a few recent sales and stock documents. Check that the restored site migrates cleanly to the same version. Ask your team who can run the restore at 2 a.m. if the patch fails.

Inventory of custom apps

List every app in apps.txt and note its source repository, branch and commit. Bench update pulls the apps you do not exclude, so an unlisted or unmaintained custom app can break the build without warning. Use the exclude-app option only for apps you have tested against the new minor release. Record the owner of each app so someone can make a decision during the update.

Server scripts and their enablement

Server Scripts run Python on document events or as API endpoints, and from version 15 they are disabled by default. Confirm whether server_script_enabled is set on your site, and list every script with its event and owner. A script that depends on a changed core method can fail after the update, so test each one on the staging site. Public shared benches on Frappe Cloud do not allow Server Scripts.

Custom fields, print formats and reports

Custom fields, property setters, print formats and custom reports live in the database, so a patch does not check them for you. Export your customizations and keep the export under version control. After the update, print a sample invoice, delivery note and purchase order, then run each custom report with real filters. Pay attention to any field that a core doctype has renamed or moved.

LDAP and Social Login Key settings

Identity settings are easy to forget because they sit outside the document flow. Record your LDAP Settings, including the SSL/TLS option and the group-to-role mapping, and your Social Login Key entries with their redirect URLs. After the update, test a fresh login with a standard user and an admin account. A broken login after a patch often looks like a network fault, so check these settings first.

Staging site cloned from production

Clone production into a staging site, run the same update there first, and time it. Keep the staging copy on the same app versions and the same customizations as production, and mask personal data if your policy requires it. Work through your closing checklist on staging, including scheduled jobs and email, before you touch production. Any failure found here is one that does not reach your users.

The minor update sequence on a production bench

This sequence moves a version 15 or 16 ERPNext site to the latest minor release with a verified backup, a tested rehearsal on a test site, and a defined rollback point, so production changes are predictable and reversible.

  1. Confirm the target release and read its notes

    Identify the minor release you plan to apply for each supported major version and read its release notes for patches, changed behavior and any companion apps that need matching versions. Confirm that your major version is still within its support window using the Frappe supported versions page. Done means you have a written target version for each app on the bench and a list of any apps that must be excluded from the update, with the reason for each.

  2. Take and verify a backup

    Create a full backup of the production site, including the database and the files directory, before anything changes. Copy the backup off the bench host to storage that survives a failure of that host. Verify the backup by confirming the archive files exist, are not zero bytes, and that the expected site name and timestamp appear in the file names. Where your team can do it safely, restore the backup to a separate machine to prove it works. The output is a backup you can name, locate and restore.

  3. Define the rollback point before changing anything

    Record the backup identifier, the current app commit or version for each app, and the bench and Python environment details in the change record. This is the rollback point: if the update fails, the plan is to restore the database and files from this backup and return the apps to these recorded versions. Agree with the business owner who has the authority to choose rollback, and what they need to see before choosing it. Done means the rollback steps are written down and someone other than the operator has reviewed them.

  4. Apply the update to the test site first

    Clone or restore production data to a test site on the same major version and the same app set, then run the planned bench update there using the same exclusions and flags you intend to use in production. Record every warning, patch output and error. Done means the test site completes the update without failed patches and the site loads in the browser after the restart.

  5. Run functional checks on key documents and reports

    On the updated test site, check the workflows your organization depends on: create, submit and cancel a sales invoice, purchase invoice, payment entry, stock entry and work order where you use them, and open the general ledger, trial balance and stock balance reports. Compare totals and outputs with the pre-update production values for the same filters. Check that print formats render and that any custom scripts or integrations still fire. Done means each check has a recorded pass or a logged defect with an owner.

  6. Schedule the window and communicate the rollback decision

    Choose a maintenance window when users are not posting transactions and the scheduler can be paused. Tell users when the site will be unavailable, and tell the approver what the rollback criteria are, such as failed patches, failed functional checks or errors in the logs. Confirm that the backup from earlier is still current or take a fresh one immediately before the window opens. Done means the window, the contacts and the rollback criteria are written in the change record and acknowledged.

  7. Run bench update on production with excluded apps

    Put the site in maintenance mode if your procedure requires it, then run bench update from the bench directory. Use exclude-app for any companion app you must hold at its current version, and confirm the exclusion does not leave a dependency mismatch. Watch the output for patch errors. Done means the command finishes without failures and the bench restarts. If a patch fails or the output shows errors you cannot resolve within the agreed window, stop and execute the rollback to the recorded backup.

  8. Verify logs, scheduler and key transactions

    After the restart, check the web and worker logs for new errors, confirm the scheduler is running and background jobs are being processed, and repeat a short set of the functional checks from the test site on production. Confirm that scheduled jobs such as email queue and recurring documents run without errors. Close the change only when the logs are clean for the agreed observation period, the scheduler is active, and the business owner has signed off the rollback point as no longer needed.

What makes a minor update take longer

This table lists the factors that change how long a bench update takes to test and apply, and what each one asks of the team. Read each row as a question to put to a partner: the more of these conditions apply to your site, the more testing and checking the update will need before it reaches production.

DriverWhy it changes effortWhat to ask a partner to scope
Custom apps and their compatibilityEach custom app must install and pass its own checks on the new minor release, and an app that pins an old dependency can block the update or force a change to its code.Which custom apps exist, who maintains them, whether they are on the same branch as the target release, and whether they are included in the test run.
Server scripts and custom codeServer Scripts are disabled by default from version 15, so sites that rely on them must confirm the enabling setting and retest document event logic after patches run.Inventory of Server Scripts, Client Scripts and hooks, which ones are enabled in production, and which hook paths the test site must exercise.
Integrations that depend on specific behaviorConnectors to banks, payment gateways, LDAP or social login rely on field names, API responses and login flows that a minor release can touch, so each one needs an end-to-end check.List of integrations with their sync direction, test credentials available in the test environment, and the owner who signs off on each result.
Database size and migrate timeLarger databases take longer to back up and to run patches against, which lengthens the maintenance window and the time the site is unavailable.Current database size, the backup method used, expected downtime window, and whether the partner measures migrate time on a copy of production.
Number of sites on one benchEach site on the bench is migrated and tested separately, so the work scales with site count and any site with unique customizations needs its own pass.Count of sites per bench, which sites share apps or customizations, and whether the update is scheduled site by site or all at once.
State of the test environmentA test site that differs from production in apps, data or configuration can pass while production fails, so refreshing and aligning the test copy often takes the most time.Date of the last refresh, how closely the test bench matches production versions and apps, and who prepares the copy and the rollback plan.
Backup and rollback readinessIf the team cannot restore a verified backup quickly, the update window must cover a longer recovery path if a patch fails.Backup schedule, restore test history, and the rollback steps the partner documents before the update starts.

Questions teams ask before applying ERPNext minor updates

How much does an ERPNext minor update cost?

A minor update has no license fee, since ERPNext and Frappe are free and open source under GPL-3.0 and MIT. The cost is labor and infrastructure: staff time to schedule the window, take and verify backups, run the update on a test site, check business processes, and deploy to production, plus any staging server you keep running. If you use an external partner, the cost follows from the written scope, which should list the number of sites, apps installed, custom code and the testing you expect. The recurring part is the cadence: ERPNext v15 and v16 both ship frequent minor releases, so each update repeats the same work. Ask any partner to quote one update cycle and the recurring support it includes separately.

How long does a minor ERPNext update take?

The bench command itself often finishes quickly, but the total window is driven by everything around it. Duration grows with the number of sites on the bench, the number of installed apps, the size of the database that migration patches must alter, and the amount of custom code that needs checking after the change. Your own test run on a copy of production gives the most reliable estimate for your environment, so plan the production window from that run rather than from a general figure. Ask any partner to state the assumed site count, app list and testing hours behind its schedule.

Can an internal team apply minor updates without a partner?

Yes, if the team has Linux administration, bench and database skills, and a documented routine. The bench update workflow backs up the site, pulls changes, installs requirements, builds assets, runs patches and restarts the bench, so the core steps are within reach of an in-house platform team. The gaps usually appear in custom apps, third-party integrations and print formats, where someone must read release notes and test each behavior. Assign an owner for the release notes review, a named tester for each business process, and a rollback plan written before the first update. Bring in outside help when the team cannot cover those roles during the update window.

What does the business need to provide for a minor update?

The business provides time from people who know the daily processes, not only from IT. Name test users from accounting, stock, sales and any other module you run, and give them a written list of transactions to repeat on the test site, such as invoice posting, payment entry, stock movements and month-end reports. Ask them to record pass or fail results and to sign off before the production window opens. Agree in advance who can approve a rollback and who must be reachable during the update.

Does Frappe warranty coverage require a matching support plan?

Yes. Frappe's supported versions policy says customers must be on a listed version and subscribed to a matching Frappe Cloud support plan to receive warranty coverage from Frappe. Confirm the current terms on the supported versions page before you rely on them, because support windows change. Self-hosting remains free, but warranty coverage is a separate question from the license. If your sites run outside Frappe Cloud, confirm with Frappe which plan applies to your version and deployment model.

Should we hire a certified ERPNext partner for minor updates?

Hire a partner when your team lacks capacity, when the site has heavy customization, or when you need documented evidence for an audit. The ERPNext pricing page says implementation is available through certified partners, so ask any firm for its Frappe certification status and for named engineers who will do the work. DeployOpen is a Chainscore Labs company that plans, implements, hardens, backs up, upgrades and documents self-hosted platforms in your own infrastructure, and it works under written, fixed-scope agreements. Ask any provider to define the update steps, testing, rollback and handover in writing, and to confirm who is responsible for each step.

What happens if a minor update fails in production?

A failed update should be handled by rollback to the backup taken before patching, so the backup must be verified before the update starts. The bench update process begins with a backup, but you still need a tested restore procedure, a recorded version of the app and code before the change, and a decision point that says when to stop and restore. Practice the restore on the test site and time it, so the team knows the cost of a rollback. Record the failed patch, the error and the restore result, then fix the cause on the test site before trying again. Confirm the exact recovery steps with the Frappe bench documentation and your own environment.

How DeployOpen works on this

DeployOpen plans, implements, hardens, backs up, documents and supports self-hosted open-source platforms inside your own infrastructure, including ERPNext. For minor updates, we set up a test site that mirrors production, define which apps stay pinned, and hand your team a repeatable runbook for each patch cycle.

How we scope

  • Written scope lists the bench, sites, apps and versions covered by each minor update cycle.
  • Scope names which companion apps are excluded from updates and who approves each exception.
  • Engagements are fixed-scope, with deliverables and timelines agreed in writing before work starts.

How we build

  • We build a test site from a recent production backup and run bench update there first.
  • Post-update checks cover accounting postings, stock ledgers, print formats, reports and custom scripts.
  • Custom apps and server scripts are retested against each release notes review before production.

How we hand over

  • You receive a written update runbook covering backup, exclude-app choices, patch review and rollback steps.
  • Test results, the release tags applied and any manual fixes are documented for your change records.
  • Your administrators are walked through the runbook so they can apply future minor releases themselves.

How we support

  • Ongoing support, scheduled minor update cycles and continuous testing are available as a retainer.
  • Retainers can cover release monitoring so your team hears about new minor versions in good time.
  • Ask for the support scope, response arrangements and change process in the written quote.

Sources and further reading

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.