ERPNext version 15 to 16 upgrade: what changes and when to start
An ERPNext v15 system with custom apps, scripts and integrations can move to v16, but only after each of those pieces has been checked against v16 in a staging copy of your production data. Start that check now. Frappe plans to support v15 until the end of 2027 and v16 until the end of 2029, so the work can be planned as a project with a deadline, a named owner and a clear go or no-go decision. The time between now and the end of 2027 is what makes the move manageable.
The upgrade is harder than running bench update and bench migrate because the commands only change the code and the database schema. Custom apps may depend on v15 behavior in hooks, overridden methods or DocTypes that changed underneath them, so they need to be tested, not just installed. Server Scripts are disabled by default from v15 and must be turned on with the server_script_enabled setting. If your business logic lives in Server Scripts, confirm that your hosting allows them, since Frappe Cloud public shared benches do not, and decide who owns that setting after the upgrade.
Ledger and stock data also need to reconcile after migration. Before the upgrade, record the General Ledger totals by account, the trial balance, stock balances and valuation by warehouse, and open invoices, payments and purchase orders. Repeat the same reports on the migrated copy and investigate every difference before users return to the system. Document which reports you trust as the reference, because a mismatch in a custom report is a different problem from a mismatch in the standard ledger.
Read the v16 release notes against your own inventory, not as a general summary. List every installed app and its version, custom fields, DocTypes, scripts, print formats, reports and integrations, then mark each item that touches accounting, stock or external systems. DeployOpen does not assume particular breaking changes without checking them, and neither should your team. Confirm the rollback plan in advance: a tested restore from a backup taken immediately before the migration, with an agreed time limit for deciding whether to roll back.
Which parts of the stack the upgrade touches
Six parts of the stack change or carry risk during the move from version 15 to 16. Each has its own compatibility question, and a failure in one often appears as an error in another, so test them together in a staging run of bench migrate before you plan the production window.
Frappe Framework and ERPNext apps
Bench moves the Frappe Framework and ERPNext to the target release and runs bench migrate against each site. Before migrate, confirm that both apps are on matching major versions and take a full backup of every site. After migrate, check that each site loads, review the migrate log for failed patches, and record the exact ERPNext minor release you tested. ERPNext ships minor releases often, so the staging and production versions should match.
Custom Frappe apps and dependencies
Custom apps are a common source of failed upgrades because their DocTypes, hooks and Python imports were written against version 15 behavior. Check each app's compatibility with version 16 in its own repository, then update its pinned Python and Node dependencies and confirm they install in the staging bench. Record the app versions installed before the upgrade so you can restore them if a rollback is needed.
Server Scripts and Client Scripts
Server Scripts run Python on document events and as API endpoints. Starting from version 15 they are disabled by default and need the server_script_enabled setting, and Frappe Cloud public shared benches do not allow them. Client Scripts run JavaScript in the browser and do not need that setting. Before migrate, inventory every script and note which ones reference fields, methods or endpoints you changed. After migrate, test each document event and API call in staging.
Data Import tool for corrections
The Data Import tool updates existing records from CSV or Excel files, including child table rows, so teams often use it to correct master data around an upgrade. Run a small test import in staging first. The documentation advises importing only a few thousand records at a time, so split large files into batches. Export the affected records before each batch, reconcile record counts and totals after it, and keep the template so the correction can be repeated.
MariaDB, Redis, workers and scheduler
The database, cache, background workers and scheduler all read and write during migrate. Confirm the MariaDB version and settings that the target release requires, and take a logical backup before you start. Pause scheduled jobs and drain worker queues so no job runs against a half-migrated schema, then restart them only after the migrate log is clean. Check Redis state against your runbook and watch the worker queues after cutover.
frappe_docker images and Compose files
If the site runs in containers, the upgrade means building or pulling images for the target release and updating the Compose file that defines MariaDB, Redis, workers, scheduler, Socket.io and Nginx. Custom apps must be included in the image again, so rebuild from the same app commits you tested in staging. Run the production configuration. The single-file demo setup is marked for short-lived evaluation only. Confirm that migrate completes in the new containers before you remove the old ones.
Choosing the upgrade path: in place, rebuilt or Frappe Cloud
This table compares three ways to move an ERPNext v15 site to v16 and the operational choices that come with each. Read each column against your current hosting, custom apps and reliance on Server Scripts. The main takeaway is that warranty eligibility and Server Scripts can decide the path before the technical effort does.
| Decision | In place: bench update and migrate | Rebuilt: image or fresh bench | Frappe Cloud |
|---|---|---|---|
| When it fits | A single self-hosted bench with tested custom apps and a verified pre-upgrade backup. | Environment drift, aging hosts, or a planned move to containers built from frappe_docker images. | Teams that want Frappe to run the environment and can work within the platform's app and script limits. |
| Downtime window | A planned window covering update, migrate and restart. Length depends on site size, so measure it in staging. | A window covering the final backup, restore into the new environment and cutover. Ask for the steps in writing. | Set by the platform's migration process. Ask Frappe to confirm how the window is scheduled. |
| Rollback difficulty | Hardest to reverse once migrate has run. Depends on a full database and file backup taken before starting. | Easiest if the v15 environment stays intact until sign-off and traffic can be switched back. | Depends on platform backup and restore options. Confirm retention periods and restore steps before committing. |
| Environment ownership | Your team owns the server, bench, system dependencies, patching and backups. | Your team owns image builds, the registry, orchestration, hosts and backups. | Frappe operates the infrastructure. Your team still owns site data, configuration and custom apps. |
| Custom app packaging | Apps stay in the existing bench and are updated there. Each app needs v16 compatibility testing. | Apps are baked into a versioned image or installed into a fresh bench from source, which makes the build repeatable. | Apps must be installed through the platform's process. Confirm which apps are accepted and how they are deployed. |
| Server Scripts | Keep server_script_enabled on only where needed. Review each script for changes in v16 behavior. | The same setting applies in the new bench. Carry the setting and scripts across deliberately during the build. | Public shared benches do not allow Server Scripts, so move that logic into a custom app before cutover. |
| Warranty coverage | Applies only on a listed version with a matching Frappe Cloud support plan. Confirm whether that plan can cover a self-hosted bench. | Same condition as in place: a listed version and a matching Frappe Cloud support plan. Confirm eligibility in writing. | Applies on a listed version with a matching Frappe Cloud support plan. Confirm the plan that matches your site. |
| Who should run it | Suits an in-house team that has run bench migrate on staging and owns the custom app tests. | Suits a team with container or DevOps skills. A partner can handle image pipelines and cutover. | Suits teams that want platform operations handled and can accept the platform's constraints. |
Which custom apps and scripts break first during an ERPNext upgrade
The first step is an inventory, and it should be complete before anyone runs a migration. List every custom Frappe app with its pinned dependencies, then every Server Script, Client Script, custom field, print format and scheduled job in the production site. Record where each item lives, which DocTypes it reads or writes, and who owns it. Then sort the list by exposure. Items that override or extend core DocTypes such as Sales Invoice, Journal Entry, Payment Entry or Stock Entry come first. Items that post to the general ledger or change stock valuation come next, followed by anything that exchanges data with an external system such as a bank feed, payment gateway, e-commerce store or payroll provider. Print formats and cosmetic client logic usually sit at the bottom. This ordering tells the team where the staging effort should concentrate.
Each item then needs two checks. The first is a read of the v16 release notes against the specific DocTypes, controller methods, hooks and APIs that the item touches. Do not assume a change is irrelevant because the feature sounds unrelated, and do not assume it applies without reading the note. Record the result for each item as affected, unaffected or unclear. The second check is a run in staging. Restore a recent copy of production, install the same custom apps at the versions the team intends to ship, run bench migrate, and exercise each document event, button, report and scheduled job against realistic records. A check passes only when the output matches the expected accounting and stock results, not when the page merely loads. Keep a simple register of item, check method, result and owner.
Custom Server Scripts need their own review. Since version 15, Server Scripts are disabled by default and run only when the server_script_enabled setting allows it. Confirm that the setting is enabled in staging and in production before cutover, and verify that each document event actually fires after the move. A disabled script does not always produce a visible error, so a missing validation or posting side effect may only surface later in a reconciliation. The move also changes where logic can live. Frappe Cloud public shared benches do not allow Server Scripts, so any script that must keep running on that tier has to move into a custom app, or the team has to choose a hosting option that permits Server Scripts. Ask the hosting provider to confirm the current plan terms in writing.
Plan for two outcomes. Items the team should expect to rewrite include overrides of core controllers, scripts that depend on internal methods that the release notes mark as changed, code that posts to accounting or stock, integration code that calls APIs whose behavior changed, and any Server Script that must run on a Frappe Cloud public shared bench. Items that can usually be retested only include print formats, custom fields with no logic attached, Client Scripts that only set field values or toggle visibility, reports that read standard tables without changing them, and scheduled jobs that call stable public methods. Even retest-only items should pass the staging run, because a dependency update can change behavior without any code change. Label each item with the expected outcome before work starts, so the quote and schedule reflect the real rewrite list.
How to run the ERPNext version 15 to 16 upgrade in sequence
This sequence moves a self-hosted ERPNext version 15 site to version 16 through a frozen baseline, a restore-tested backup, and repeated migrate runs on a masked staging copy. Each step closes with a check that must pass before the next one starts, so the production migrate is a scheduled decision based on evidence rather than a final attempt.
Freeze the v15 baseline
The site owner and the upgrade lead stop non-urgent changes to customizations and record the exact Frappe and ERPNext versions, every installed custom app with its version or commit, and the site configuration. Export customizations, scripts, custom fields, print formats, workflows and scheduled jobs so they can be compared later. Check: the baseline record lists every app and configuration file, and a second person has reviewed it and confirmed nothing is missing.
Back up and prove the restore
Take a full bench backup that includes the database and the private and public file directories, and copy it to a location outside the production server. Restore that backup to a separate machine and open the site, then compare record counts and a sample of recent transactions with production. Check: the restored site starts, logs in and matches the sampled data. A backup that has not been restored is not accepted as the rollback point.
Clone production into masked staging
Create an isolated staging environment with no path to production email, payment gateways, banking connections or outbound integrations, then clone the site from the verified backup. Where your data protection policy requires it, mask personal data such as customer contacts, employee details and bank fields before users get access. Check: staging is confirmed to be unable to send messages or call live external systems, and the masking report shows which fields were changed.
Install v16 releases and upgraded apps
Install the matching version 16 Frappe and ERPNext releases on the staging bench, then install each custom app at a version confirmed to support v16. Where a third-party app has no v16 release, record it as a blocker before going further. Confirm with the vendor or app maintainer what each app needs. Check: every app installs cleanly, the bench reports the expected versions for all of them, and the list matches the baseline from step one.
Run migrate and log every output
Run bench migrate on the staging clone and capture the complete console output, including errors, warnings and skipped patches, in a file that stays with the upgrade record. Review each failed or skipped patch for its cause, whether it comes from a custom app, a Server Script, a custom field or core data. Check: migrate finishes without an unexplained error, and every warning is classified as accepted, fixed or blocking in the log.
Fix custom code and rerun from clean
Correct the custom apps, scripts and customizations flagged in the log, and commit each fix to version control. Do not patch the staging database by hand, because that hides the cause from the next run. Restore a fresh clone from the verified backup, apply the corrected code, and run migrate again from the beginning. Check: two consecutive clean migrate runs from fresh clones produce the same log, with no manual database edits recorded.
Test data and integrations
Compare key balances, stock valuations, open invoices and outstanding payments in v16 staging with the v15 baseline, and document every difference with an explanation. Run the business processes your teams depend on, such as order to invoice, purchase to payment, production and month-end reports. Test each integration against a sandbox or test endpoint, including authentication, webhooks and error handling. Check: every difference is explained and approved by the finance owner, and each integration completes its test cases.
Rehearse cutover and decide go or no-go
Perform a timed production cutover rehearsal on a staging copy using the exact steps, communications and approvals planned for production. Include a rollback drill that restores the v15 backup and confirms users can work on the old version. Record the measured times, problems and owners, then schedule the production migrate with a go or no-go decision signed by the business owner and the technical lead. Check: the timed run and rollback drill both succeed, and the decision record names the approvers and the conditions for proceeding.
Rollback planning for a bench migrate that goes wrong
Rollback has to be planned before the production migrate starts because bench migrate changes the database schema and transforms data in place. Reverting the apps to their v15 commits does not undo those changes, so a site left on v16 code with a v15 database, or the reverse, will fail in ways that are hard to diagnose. The only dependable way back is to restore the backup taken immediately before the maintenance window onto a v15 bench with matching app versions. This section covers what that backup must contain, how to prove it works, how long the old environment stays available, and who decides between rolling back and fixing forward.
The rollback point is a full bench backup taken after the site enters maintenance mode and after the final pre-cutover sync of transactions, so no writes occur between the backup and the migrate. It should include the database, the public and private files, and a written record of the exact ERPNext and Frappe releases and the commit of each custom app. Store that record with the backup, because a restore is only useful if the team can rebuild the same v15 bench that produced it. Before starting the migrate, confirm the backup set is complete, and keep a copy off the upgrade host so a failure there cannot remove both the live site and the rollback point.
A backup that has never been restored is an assumption, not a rollback point. During the staging rehearsal, restore the pre-migrate backup to a separate v15 bench, start the site, log in, and check a sample of recent sales invoices, payment entries and stock ledger entries against the values recorded before the rehearsal migrate. Time each step: taking the backup, copying it, restoring the database, restoring the files, rebuilding the v15 bench and reaching the first successful login. These measurements define the rollback window you can responsibly commit to. Ask the partner to state in writing the restore procedure, the evidence they will produce from the rehearsal, and who runs the restore during the window.
Keep the v15 environment intact until the business has signed off the v16 site and the agreed post-cutover monitoring period has closed. That period, along with the hosting and storage cost of keeping the old bench and backups available, belongs in the plan and the quote, not in an assumption. Set decision criteria before the window opens. Roll back if the migrate fails and cannot be repaired within the agreed window, if reconciliation of ledgers, stock balances or open documents shows differences that finance cannot explain, or if a custom app or script breaks a core process with no safe fix. Fix forward when the problem is contained, reversible and does not touch financial data. Name one person with authority to call the rollback, a finance approver for ledger decisions, and an escalation path agreed in advance.
What drives the effort and cost of the upgrade
This table lists the drivers that change the size of a version 15 to 16 upgrade, with how each one raises effort and how to keep it down. Read each row against your own inventory of apps, scripts, integrations and sites, because the combination of these drivers usually matters more than any single item. ERPNext itself is free under GPL-3.0, so the cost you pay is for the work, the testing and the hosting, and the final figure comes from a written scope.
| Driver | Why it raises effort | What reduces it |
|---|---|---|
| Custom apps: number and complexity | Each app needs a compatibility check against version 16 changes, its own patches and tests before bench migrate runs. | Inventory every app, remove unused ones, and keep custom code in version-controlled apps with automated tests. |
| Server Scripts and Client Scripts: count and location | Server Scripts are disabled by default from version 15 and must be enabled. Shared Frappe Cloud public benches do not allow them. | List each script by DocType and event, move stable logic into a custom app, and retire scripts nobody uses. |
| Data volume and number of sites or companies | Each site is migrated and tested separately, and multi-company ledgers need reconciliation before and after the run. | Archive closed periods where policy allows, rehearse on a recent copy, and reconcile balances per company. |
| Integrations with banking, e-commerce, payroll or other systems | Each system that calls the API or receives webhooks may depend on fields or responses that change in version 16. | Document each endpoint and payload, test each one in staging, and agree a switch-over order with system owners. |
| Staging and test environments | A dry run needs a production-like copy, and every repeat of the migration needs a fresh database and a full test cycle. | Script the environment refresh, keep one staging site per dry run, and record how long each step takes. |
| Customization of accounting and stock logic | Changes to posting, valuation or stock ledgers need finance sign-off plus trial balance and stock checks after the upgrade. | Use standard settings where possible, limit overrides, and agree the reconciliation pack before testing starts. |
| Hosting model: self-hosted, Frappe Cloud or containers | Self-hosted sites carry backups and bench updates in-house. Containers need image rebuilds with custom apps. Hosting cost is separate from upgrade work. | Choose the hosting model before scoping. The ERPNext pricing page lists Frappe Cloud hosting from 5 US dollars per month, for hosting only. |
| Compliance evidence that must be kept | Change records, test results, access logs and restore tests may be requested by auditors for the upgrade period. | Define the evidence list at scoping, store test outputs with each run, and confirm retention rules with your auditor. |
How to confirm the upgraded site is correct before go-live
Accounting checks prove that the upgrade did not change what the business has already recorded. Run the same reports on the staging site and on the frozen v15 baseline, using the same company, fiscal year, filters and export date.
- Balances: General Ledger totals per account and per company match the baseline to the currency unit.
- Trial balance: Opening and closing balances for each period and cost center match, including the fiscal year rollover.
- Outstanding invoices and payments: Sales and purchase invoices, payment entries and their allocations show the same outstanding amounts.
- Period status: Closed accounting periods stay closed, and any reopening follows the approved change process.
Expected evidence is the exported trial balance, outstanding reports and a variance log with every difference explained. The finance controller signs off. The site fails safely when any unexplained variance remains, because the team stops, keeps the v15 site as the system of record and repeats the migration from the frozen backup. Confirm the sign-off owner and the variance tolerance in writing before the staging run begins.
Stock checks confirm that goods on hand and their value survived the move. Compare warehouse-level results against the v15 baseline taken on the same day, because a single item with a different valuation rate can distort the balance sheet for the whole period.
- Stock balance: Quantities per item and warehouse match the baseline in the Stock Balance report.
- Valuation: Valuation rate and stock value per item match, including items with multiple batches or serial numbers.
- Bin quantities: Actual, reserved and projected quantities in each bin match the baseline.
- Open documents: Delivery notes, material requests and work orders that reserve stock still show the same reserved quantities.
Expected evidence is the exported stock balance and valuation reports, plus a short list of any items that needed a documented correction. The stock controller and the operations lead sign off together. The site fails safely when valuation differs for any item or when reserved quantities change, because a stock mismatch often appears only after users start transacting in v16. Ask the implementation team which reports they will use so both sides compare identical outputs.
Custom code checks exercise every custom app, script and scheduled job with inputs whose outputs are known in advance. Start from an inventory of each app, its version and every server script, client script, print format and scheduled job that depends on it.
- Server scripts: Confirm the server_script_enabled setting on the staging site. Starting from version 15, Server Scripts are disabled by default, so the team should decide deliberately whether they stay enabled in version 16.
- Client scripts and print formats: Open each affected form and print format with a test document and compare the result with the expected output.
- Scheduled jobs: Trigger each job manually with a prepared dataset and check the documents it creates or updates.
- Custom apps: Run the app's own test suite where one exists, then review error logs after each test.
Expected evidence is a test case sheet with inputs, expected outputs, actual outputs and log extracts. The application owner and the developer sign off. The site fails safely when any test errors, produces an unexpected document state or leaves a scheduled job incomplete, because the team stops before the code runs against live transactions. Ask for the list of custom apps and their pinned versions before the staging run starts.
Integration checks confirm that systems connected to ERPNext can still sign in, read, write and receive events after the upgrade. Use test accounts and non-production endpoints so that a staging run never sends data to a live partner system.
- API calls: Run a set of read and write calls with a service account against known records, and compare the responses with the v15 results.
- LDAP sign-in: Where LDAP is used, log in with test users from each group and confirm that group to role mapping still assigns the expected ERPNext roles at login.
- Social Login: Where Social Login Keys are used, complete a sign-in through each configured provider, including any custom OAuth or OpenID Connect endpoint.
- Webhooks: Trigger a sample event and confirm that the receiver gets the payload and that its signature check passes.
Expected evidence is a call log, a sign-in test record for each provider and directory group, and webhook delivery receipts. The integration owner and the security lead sign off. The site fails safely when a sign-in fails, a role mapping changes or a webhook sends to an unexpected address, because each of these can grant access or expose data. Confirm with the identity team which test accounts they will provide for the staging run.
Data import checks re-import a sample of records to prove that the upgraded database and the import tooling both behave as expected. The ERPNext Data Import documentation advises importing only a few thousand records at a time, so plan the sample in batches of that scale or smaller.
- Sample selection: Pick records from each important DocType, including records with child table rows, linked masters and custom fields.
- Batch import: Re-import each sample in batches of a few thousand records or fewer, and keep the import log for every batch.
- Reconciliation: Compare record counts, child row counts and key totals before and after each batch.
- Naming and links: Confirm that updated records keep their naming series and that links to masters still resolve.
Expected evidence is the batch log, the reconciliation sheet and any error file with its resolution. The data owner signs off. The site fails safely when a batch creates duplicates, drops child rows or breaks links, because the team stops the import and restores from the frozen backup before users begin work in version 16. Ask the vendor or partner to confirm the batch size they used in testing.
What to monitor, back up and document after the upgrade
Keep the version 15 backup, the bench directory and the v15 environment intact until the exit point written into the upgrade scope. That exit point should be a named decision made by the business, recorded with the person who approved it. Until then, keep a restorable copy of the v15 database, the sites folder, the apps list and the site configuration files, and confirm that a restore to a separate host has actually been tested. Record where the backup is stored, who can access it and how it is kept off the production network. Ask your partner or internal team to confirm how long the v15 environment will stay powered on and who has authority to retire it, because that approval is what closes the rollback window.
Monitoring after cutover should cover three places where failures usually appear first: scheduled jobs, background workers and custom code. Review the Scheduled Job Log and the Error Log DocType daily during the first weeks, and check the bench logs for worker and scheduler errors. Pay particular attention to Server Scripts. From version 15 they are disabled by default and need the server_script_enabled setting, so confirm which scripts are enabled on the migrated site, whether each one still runs, and whether any call from a custom app or an integration now fails without an obvious message to the user. Set alerts on repeated failures of the same job, since one recurring error often points to a broken integration.
Both supported lines receive frequent minor releases, so the post-upgrade plan needs a standing testing routine. The frappe/erpnext releases page lists v16.51.1 as published on October 15, 2026 and v15.123.0 on October 14, 2026, which shows the pace on both lines. Apply each minor release first to a staging copy built from a recent production backup. Run the custom app test cases and the critical document flows, such as sales invoices, stock entries and payroll runs, and only then promote the release to production. Read each release note for changes that touch Server Scripts or custom app hooks. Keep staging on the same release as production so that test results remain comparable, and agree a review rhythm with your partner before go-live.
Document the upgrade as it happens rather than reconstructing it afterwards from memory. The record should hold the final app versions and the commit or tag used for each custom app, the migration log with start and end times and any errors, the data check results with reconciliation totals for ledgers, stock and open documents, and every decision taken during cutover with the person who approved it. For each custom app, name one owner who answers for its code, its test cases and its next upgrade. Store the record alongside the v15 backup so both can be read together during any later investigation. For support, upgrades and retainer options after this point, see the ERPNext upgrades and support page.
Questions teams ask before upgrading ERPNext from v15 to v16
How much does an ERPNext v15 to v16 upgrade cost?
The cost comes from a written scope, and no price is listed here. The main components are assessing your custom apps, scripts and integrations, a staging run of bench migrate, data checks on accounting and stock records, testing by your business owners, the cutover itself, and rollback preparation. Each component is work someone is paid for, either DeployOpen under a fixed-scope agreement or your internal engineers as staff time. The main cost drivers are the amount of custom code, the number of integrations that call ERPNext, the state of your existing data, and how many modules you use. Ask for a quote that lists each component separately, its deliverables, and which items are one-time versus recurring, such as hosting or a Frappe Cloud support plan. Self-hosting ERPNext carries no license fee under GPL-3.0, so most of the cost is labor and infrastructure.
How long does an ERPNext v16 upgrade take?
Duration depends on the effort drivers, and no timeline is given without a written scope. The biggest drivers are the amount of custom app code and server scripts that need compatibility checks, the number of integrations, the volume and quality of existing data, the modules in use (accounting, stock, manufacturing, projects), and how quickly your owners can test and sign off. Each staging run can reveal new issues, so the number of rounds matters as much as the length of each one. A cutover window must also be agreed in advance, and it often sets the fixed point around which the rest is planned. Ask for a schedule that shows staging rounds, test cycles, sign-off points and the cutover date, and note which dependencies sit with your team.
What does our team need to provide for the upgrade?
You need named owners and an agreed cutover window. Name one owner each for finance (chart of accounts, ledgers, taxes and period closing), stock (items, warehouses, valuation and opening balances), and integrations (every system that calls ERPNext through the API or webhooks, plus whoever can test it). Name an executive sponsor who can approve the go or no-go decision. These owners must join the test cycles, not only the final check, because they confirm that reports and balances match before and after migration. The cutover window is a period when users stop posting transactions, so business leaders must agree to it in advance. Also provide access to a staging copy of production, the source code of custom apps, and a recent backup that you have verified by restoring it.
Can our own engineers upgrade ERPNext from v15 to v16?
Yes, if your engineers have bench and database skills and you have a tested backup. The work involves running bench commands on a staging copy, reading migration output, fixing custom app incompatibilities, checking database changes in MariaDB, and rolling back if the migration fails. Engineers who have worked only in the browser interface will need time to build these skills. A tested backup means you have restored it to a separate server and confirmed that users can log in and that balances match. Your team should also review server script settings, since Server Scripts are disabled by default from version 15 and any script that depends on them must be checked. If some skills are missing, your staff can run the staging rounds while a partner supports cutover, or the reverse. Be realistic about how much time your staff can give alongside their normal duties.
When does ERPNext v15 support end?
Frappe's supported versions page plans support for version 15 until the end of 2027 and for version 16 until the end of 2029. Version 14 reached end of life on January 31, 2026. These are planned dates, so confirm the current windows on the supported versions page before you set an internal deadline. Both branches receive frequent minor releases, so staying on a supported minor is ongoing work, not a single event. Plan the upgrade with enough buffer before the end of 2027 so that staging, testing and cutover do not compress into the final months. Ask your team to track these dates and to check whether any custom app depends on behavior that changes between v15 and v16.
Does Frappe warranty still apply after upgrading to v16?
Frappe warranty coverage depends on two conditions: you must be on a listed version, and you must hold a Frappe Cloud support plan that matches that version. After the upgrade, confirm that your subscription and plan match v16 before cutover, and do not assume that coverage carries over from v15. Warranty is a Frappe offering and is separate from DeployOpen's services, which cover planning, testing, migration and documentation under the agreed scope. Self-hosted deployments need the same check against Frappe's supported versions policy. Ask Frappe in writing which plan and version apply to your setup, and add that confirmation to your cutover checklist.
What should a staging run of the v16 migration check?
A staging run should confirm that bench migrate completes without errors, that custom apps install and load on v16, and that scripts, print formats and reports behave as expected. Compare key outputs before and after the run: trial balance, stock balances by warehouse, open sales and purchase documents, and outstanding receivables and payables. Test each integration with realistic payloads on staging, including API keys, webhooks and error handling. Review the database for unexpected changes and keep the migration log with each run. Records loaded through the Data Import tool should be verified in batches, since the documentation advises importing only a few thousand records at a time. Repeat the run from a fresh copy of production until results are consistent, and record each issue and its fix.
How DeployOpen scopes, builds and hands over an ERPNext upgrade
DeployOpen plans the move from ERPNext version 15 to version 16 as a fixed-scope engagement, with scope agreed in writing before work starts. The work runs in your own infrastructure, from compatibility review of custom apps and scripts through a staging run of bench migrate to rollback planning. Ongoing support is available as a retainer.
How we scope
- The written scope lists every custom app, client script and server script in the upgrade.
- Server Scripts are disabled by default in version 15, so we confirm which sites enable them.
- Fixed-scope terms state deliverables, acceptance criteria and dates before any upgrade work begins.
How we build
- Build a staging copy of production, then run bench migrate against it with the full data set.
- Test each custom app and script on v16 and log every change needed for compatibility.
- Check record counts, opening balances and ledger totals before and after the migrate step.
How we hand over
- Deliver a runbook with the exact upgrade steps, commands, checks and owner for each step.
- Document a rollback plan with backup points, restore steps and the decision criteria for using it.
- Walk your administrators through post-upgrade checks, custom app changes and known issues from testing.
How we support
- Confirm your version and support plan, since Frappe warranty coverage depends on a listed version and matching plan.
- Schedule ERPNext minor releases on both supported major versions, with tested updates applied in staging first.
- Frappe's published support window for version 16 runs until the end of 2029.

