ERPNext version 14 end of life: what it means for your self-hosted site
ERPNext and Frappe version 14 reached end of life on January 31, 2026, so a self-hosted site on version 14 must move to version 15 or version 16. Staying where you are is no longer a supported option. The supported versions page from Frappe lists version 15 as planned for support until the end of 2027 and version 16 until the end of 2029, so the choice is about which window fits your planning cycle. Version 16 gives the longer runway, while version 15 is the shorter step with a more familiar set of apps and customizations. Either way, the move is one major version at a time, so a site on version 14 cannot jump straight to 16 without passing through 15 first. For a self-hosted accounting and stock system, the risk of running an unsupported version is practical as well as formal. Frappe states that customers must be on a listed version and subscribed to a matching Frappe Cloud support plan to receive warranty coverage from Frappe, so a site that stays on version 14 loses that coverage. Your general ledger, stock ledger and print formats will keep running, but any defect or security issue will not be fixed on the version you run. Confirm with your own team and any partner which support arrangement applies to your sites, and check the supported versions page before you set a date.
Before you choose a target, inventory the site as it stands. List every installed app, including companion apps such as Frappe HR, Lending, Payments and India Compliance, and note which custom apps, server scripts and client scripts each one depends on. Confirm whether server scripts are enabled, because from version 15 they are disabled by default and must be turned on with the server_script_enabled setting. Record your backup schedule and restore tests, since each major step needs a fresh backup and a rehearsal on a copy of production. The version you choose determines which app branches and runtime versions you test against, so the inventory should come first.
Version 15 or version 16: which target fits your site
Support windows are the first filter. According to Frappe's supported versions page, version 15 is planned to be supported until the end of 2027 and version 16 until the end of 2029. A site that must leave version 14 quickly and does not plan to upgrade again soon may find version 15 the shorter hop, because it changes fewer things at once. A site that expects to stay on one major line for several years will get more runway from version 16, even though the upgrade itself carries more change.
- Version 15 window: Planned support runs to the end of 2027, so a move there commits you to another major upgrade within roughly two years.
- Version 16 window: Planned support runs to the end of 2029, which covers a longer planning cycle.
- Hop size: Version 15 is the smaller step from version 14, which lowers the number of changes you must test in one go.
- Dates are plans: Frappe describes these as planned windows, so confirm the current dates on the supported versions page before you commit.
Before you decide, ask your team how many years the site must run on this release and when your next budgeted upgrade cycle starts.
The two targets expect different runtime stacks. Version 16 moves to a newer Python and Node baseline, which affects the operating system, the bench environment and any custom code that depends on the older interpreter. Version 15 keeps closer to the stack a version 14 site already runs, which can reduce server rebuilds during the first hop. Treat these differences as inputs to your build plan, not as details to settle later.
- Python baseline: Version 16 expects a newer Python release than version 15, so check whether your base image or server OS can supply it.
- Node baseline: Confirm the Node version each target needs for asset builds on your build hosts.
- Operating system: Verify that your distribution packages the required runtimes or that your Docker base image provides them.
- Server rebuilds: A newer baseline may require new hosts, new images or a longer staging window.
Confirm the exact Python and Node versions for each target in the Frappe documentation and the release notes for the version you choose, and match them against your current servers.
Custom apps usually decide the target more than the core ERPNext code does. Every custom Frappe app must install and migrate cleanly against the target, and apps that rely on framework behavior removed or changed in a newer release will need code work. A site with few or no custom apps can often move with fewer changes, while a site with many custom scripts, hooks and integrations should expect the chosen target to drive the size of the project.
- Hook and permission changes: Review custom hooks and permission logic, since behavior can differ between releases.
- Removed or changed methods: Check whitelisted methods and server scripts against the target's documentation. Server Scripts are disabled by default from version 15 and must be enabled with
server_script_enabled, so confirm whether your site depends on them. - Companion apps: Confirm that every companion app you use has a matching branch for the target before you migrate.
- Test coverage: Sites with thin test coverage benefit more from a version that changes fewer things.
Ask each custom app owner which framework features the app uses and whether a branch for each target exists.
Both supported majors receive frequent minor releases, so the choice of target does not decide whether you get fixes. According to the frappe/erpnext releases page, v16.51.1 was released on October 15, 2026, and v15.123.0 on October 14, 2026. Both lines were actively maintained at the same time, which makes the minor update routine the same in practice. What differs is how long each line is supported and how often you will need a full major upgrade.
- Shared minor cadence: Both lines ship frequent patch and minor releases, so plan a recurring update window for either target.
- Update process: Routine minor updates follow the same bench update pattern on either line, with backups and a test site first.
- Major upgrade timing: The end of planned support is the trigger for the next major move, so schedule it against the support dates.
- Warranty coverage: 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, so check the plan that matches your target.
Ask your provider how they will handle minor releases during the period you stay on the target.
A practical decision combines the support window, the runtime baseline and the state of your custom apps. Sites with a short planning horizon, a modest custom footprint and no near-term need for newer runtimes often pick version 15. Sites that want a longer support window, can rebuild their runtime stack and have custom apps that already work on version 16 often pick version 16. Neither answer is correct for every site, so record the reasoning in writing.
- Horizon: Write down how many years the site must run on the target.
- Runtime: Confirm the Python and Node versions for each target in the Frappe documentation.
- Apps: List each custom and companion app with its branch status for each target.
- Owners: Name who approves the target, who tests it and who signs off the cutover.
- Timeline: Set the next major review date against the planned support end date.
Before you commit, review the supported versions page and the release notes for your chosen target, and confirm every dependency in writing with your app owners and your hosting provider.
What changes between version 14 and the target versions
This table lists the changes that affect a self-hosted version 14 site as it moves to version 15 or 16. Read each row as a question to answer against your own customizations and integrations before scheduling the upgrade. Confirm exact release contents on the ERPNext releases page, since only the items below are established here.
| Change | Impact on a version 14 site | Action needed |
|---|---|---|
| Server Scripts disabled by default from version 15 | Server Scripts that run on document events or as API endpoints will not execute until the feature is turned on | Inventory every Server Script, then decide whether to enable server_script_enabled or move the logic into a custom app |
| Frappe Cloud public shared benches do not allow Server Scripts | Scripts that work on a self-hosted site may fail if the same code is later moved to a public shared bench | Confirm the hosting target before rewriting scripts, and avoid designs that depend on Server Scripts for core business logic |
| Apps split out of the ERPNext core | Functionality such as Lending, Payments and E-commerce is no longer bundled, so features may disappear until the separate apps are installed | List every module in use, map it to its companion app, and install matching app versions before running migrate |
| Companion app version matching | Mismatched branches between ERPNext and its apps can block bench migrate or break document behavior | Pin each app to the branch that matches the target ERPNext version and test the combination on a staging site |
| Requirements for version 16 (Python and Node) | The runtime versions a version 16 host needs can differ from those used on a version 14 host | Check the version 16 release notes for the exact Python and Node requirements before rebuilding the host or images |
| Custom apps and hooks | Custom code written against version 14 APIs or hooks may need changes, and this is a common source of upgrade delays | Run custom apps against the target version on a test site and review each hook and whitelisted method |
| Print formats, reports and customizations | Layouts and reports built on older field names or structures can render incorrectly after migration | Retest print formats and reports with production-like data and record each fix |
| Support status of the current version | Version 14 reached end of life on January 31, 2026, so it no longer receives Frappe support updates | Confirm your support option in Frappe's supported versions page and set a target version and date with stakeholders |
How to prepare a version 14 site before any upgrade
Before any bench migrate runs against a version 14 site, the data, the customizations and the integrations need to be known and recoverable. The six items below cover what to capture, what to test and what to check, so the upgrade starts from a documented baseline.
Full backup, tested by restore
Take a full backup of the database and the site files, then restore it to a separate host and confirm the site opens and the records match. A backup that has never been restored is an assumption, not a recovery point. Record the ERPNext and Frappe versions and the installed apps alongside the backup so the rollback path is clear. Confirm with your team how long a restore takes on your hardware, since that time sets how long a failed upgrade can stay offline.
Inventory of custom apps
List every custom Frappe app, its source repository, its branch or tag and the Frappe and ERPNext versions it was built against. Note which apps depend on hooks, overridden controllers or whitelisted methods that changed between versions. Each app needs an owner who will retest it after the upgrade. Apps without a Git source or an owner are the most likely to block the upgrade late in the project.
Client and server scripts
Export every Client Script and Server Script, including the document events they hook and the API endpoints they expose. Server Scripts are disabled by default from version 15 and must be enabled with the server_script_enabled setting, so decide which scripts move to a custom app before the upgrade. Frappe Cloud public shared benches do not allow them. Mark each script as keep, rewrite or retire.
Custom fields, print formats and reports
Export custom fields, property setters, custom DocTypes, print formats, custom reports and workspaces as fixtures or JSON so they can be compared before and after the upgrade. Print formats and reports that reference fields renamed or moved between versions are common failure points. Keep a short list of the documents that must print correctly, such as invoices and delivery notes, and test each one on the test site.
Integrations and login methods
List every external connection, including LDAP through LDAP Settings, Social Login Key providers, payment gateways, bank feeds, email accounts and API users with their tokens. For each one, record the endpoint, the credential owner and the test that proves it works. Re-test LDAP group-to-role mapping and OAuth redirect URLs on the test site, since a changed callback URL silently blocks sign-in for every user.
Test site and data check plan
Clone production to a test site and run the full upgrade there first, with the same apps and the same data volume. Pair the clone with a data check plan: reconcile ledger totals, stock balances and open document counts before and after each step. Include the records loaded through the Data Import tool, since imports made in batches are a common source of duplicates or missing child rows that only show up after migration.
The upgrade sequence and rollback points
The sequence gives you a tested path from the end-of-life version 14 site to a target version, with a defined rollback point before every migration. Production changes only after the same steps have passed on a test copy.
Freeze the source site
Stop routine data entry, scheduled jobs that write records, and integrations that push data into the site, and record the exact ERPNext and Frappe versions and the list of installed apps. The owning team signs off on the freeze window, and the freeze is lifted only after the cutover is confirmed. Done means you have a written inventory of versions, apps, custom fields, scripts and integrations to carry forward.
Back up the source site and record the rollback point
Take a full database and files backup of the frozen site, store it outside the server being upgraded, and check that it restores. Label this backup as the rollback point for the production migration. Confirm the backup commands and retention settings against the bench documentation for your version. Done means a restore of the backup has been tested on a separate host.
Stage a test copy of the site
Restore the backup onto a separate test bench with the same operating system, database and Redis setup as production, so the test copy matches what production will see. Keep outbound email, payment connectors and external integrations disabled on the copy so it cannot send messages or sync data. Done means the copy loads and the version and app list match the source inventory.
Install matching branches of companion apps
Install the companion apps that split out of ERPNext for the target version, along with any custom apps, using branches that match the target version. Check the release notes for each app and the version support page before choosing branches, and confirm which apps your site needs. Done means every app installs cleanly and the app versions are recorded alongside the ERPNext version.
Run the migrate step on the test copy
Run the migrate step on the test copy, then review the log for errors, failed patches and warnings before going further. Fix any failing patch or custom app issue on the test copy and repeat the migration from the rollback backup until it completes cleanly. Confirm the exact migrate and update commands with the bench documentation for your target version. Done means a migration completes with no unresolved patch errors.
Verify login, scripts, reports and background jobs
Test login, LDAP and social login, server and client scripts, key reports, print formats, the scheduler and background jobs, and the integrations you disabled earlier. Scripts need the setting that enables server scripts on the target version, and the scheduler must run before you trust scheduled tasks. Keep a written checklist and record each result with the tester's name. Done means every check on the list passes or has an agreed fix.
Repeat the sequence on production with a rollback point
Schedule the production cutover, repeat the freeze, backup and migrate steps in the same order, and take a fresh backup immediately before the migration as the rollback point. If the migration or the verification checks fail, restore from that backup and return the site to its previous version. Done means production passes the same checks as the test copy, and the rollback backup is kept until the owning team accepts the upgrade.
What makes a version 14 upgrade take longer
How does the amount of customization affect an ERPNext upgrade?
Customization is usually the largest driver, because every custom app, script and report has to be retested against the target version. Each custom app needs a branch or release that matches the new Frappe Framework version, and any code that calls changed or removed methods needs rework. Custom print formats and reports are easy to overlook, but they often break in subtle ways and need visual and numeric checks. Ask for a full inventory of custom code, fields, print formats and reports before agreeing on scope, since that inventory sets most of the test effort.
Why do server scripts complicate an upgrade from version 14?
Server Scripts run Python on document events or as API endpoints, and from version 15 they are disabled by default. A site that relied on them will stop behaving as before until the server_script_enabled setting is turned on, and that change needs an explicit decision on your side. Hosted shared environments may not allow Server Scripts at all, so confirm your hosting model early. Each script also needs review against the new document lifecycle, which adds effort in proportion to how much logic lives in scripts rather than in standard configuration.
Which companion apps must match the target version?
Several apps were split out of ERPNext in later releases, and they must be installed at versions that match the target Frappe and ERPNext versions. Typical examples include Frappe HR, Lending, Payments, India Compliance and Ecommerce Integrations, depending on what your site uses. Each one adds an installation, a migration step and its own test cycle. Ask for a list of every installed app and its current branch so the matching targets can be planned before the first migration runs.
Do LDAP and social login need retesting during an upgrade?
Yes. Identity integrations are easy to assume will keep working, yet they depend on configuration that can change between versions. LDAP Settings, including SSL/TLS options and the automatic mapping of LDAP groups to ERPNext roles at login, should be verified with test accounts from each group. Social Login Keys for providers such as Google, Microsoft or a custom OpenID Connect endpoint need a test sign-in and a check that users land with the right roles. Plan these checks as a separate test set, because a login failure blocks every user at once.
How does data volume change the time an upgrade needs?
The migration itself runs against your database, so larger sites with more history, stock ledger entries and submitted documents need more time for the migrate step and for verification afterward. Data import is a separate concern when you load records during or after the move. The Data Import tool is documented for importing only a few thousand records at a time, so bulk corrections should be batched and checked. Ask for database size, record counts for the main accounting and stock doctypes, and a timed run of the migration on a copy of production.
How does the number of sites on one bench affect the upgrade?
Every site on a bench is migrated, tested and rolled back as a unit of work, so the effort grows with the number of sites and with how different they are. Sites that share the same apps and customizations can follow one checklist, while sites with different companies, currencies or custom apps need separate test passes. Shared benches also mean that one app upgrade affects all sites at once. Confirm the site count, the apps each one uses, and whether any site must stay on the old version for a period.
What test environment do you need before upgrading?
A test environment that mirrors production is the single most useful way to shorten risk and rework. It should use a recent copy of the production database, the same apps at the same versions, the same identity settings and the same hosting model, so that errors surface before cutover. Without one, problems surface in production and the rollback plan becomes the main activity. Confirm whether you can provide a separate server or cloud account, how fresh the data copy can be, and who signs off on test results.
Can our own team do a version 14 upgrade without a partner?
A team with Linux, Frappe bench and database experience can perform an upgrade, and the upgrade path is documented in the Frappe ecosystem. The effort is still driven by the factors above, especially custom code, companion apps and test coverage. Teams without that experience often underestimate the time spent on retesting and rollback rehearsal. DeployOpen plans, implements and documents this kind of work under a written, fixed scope, so you can compare an internal estimate with an agreed scope before deciding.
Questions buyers ask before outside help
The first question most buyers ask is what an upgrade off version 14 will cost and how long it will take. The honest answer is that both depend on written scope, and a DeployOpen quote follows from that scope rather than from a standard price. The scope has to name the sites, the installed companion apps, the custom apps and scripts that must be retested, the data volumes, the number of environments, and whether the target is version 15 or version 16. A site with stock, accounting and a few print formats is a different job from a multi-company site with custom DocTypes and integrations, even on the same version. Ask for the scope to be written down before any work starts, with each deliverable and acceptance check listed.
The second question is whether your own team can do the upgrade. A self-hosted team can, provided it has engineers who have run bench migrate on production-sized data, a staging site restored from a recent backup, and a tested rollback path. Check those three things before deciding. Confirm that your team can read the breaking changes for each major version, that someone owns the decision on version 15 or 16, and that business users have time to test their own workflows. If any of these are missing, ask for an outside scope that covers only the gaps, such as the staging rehearsal or the custom app retest, and keep the cutover in-house. Either way, the quote and the internal plan should describe the same environments and the same exit criteria.
ERPNext upgrade FAQ: cost, time and what you must provide
What drives the cost of an ERPNext version 14 upgrade?
The cost follows the size and shape of your installation, not the version number alone. The main drivers are the number of sites and companies, how much custom code and custom apps you run, how many companion apps (such as Frappe HR, Lending, Payments or India Compliance) must be installed, the volume and quality of data to check, and how many integrations need retesting. Self-hosting ERPNext itself is free under GPL-3.0, so the cost is labor: planning, the staged upgrade, testing, fixes and handover. Ask for a quote that lists each of these as a separate line, with what is one-time (the upgrade and cutover) and what recurs (minor updates and support retainers, if you choose them).
How long does an ERPNext upgrade take?
Duration depends on how much needs to be checked, not on the upgrade command itself. Plan for time to inventory apps and customizations, build a test site from a recent backup, run the migration, fix print formats, reports and scripts, validate data, and rehearse the production cutover. Scope and timelines are agreed in writing before work starts, so ask for a written schedule with milestones and the assumptions behind it. The Frappe version support dates are a fixed input: version 14 reached end of life on January 31, 2026, according to Frappe's supported versions page.
What do we have to provide for an ERPNext upgrade?
The work needs access and information that only your team can supply. Typically this includes:
- Administrative access to the servers, bench or container hosts, and the database for a test copy of production
- A current, verified backup and a list of sites, companies and installed apps
- Test data that reflects real transactions, including accounting, stock and production records
- Named business owners who can sign off on finance, stock, manufacturing and reports
- Any custom apps, scripts and integration credentials, plus the vendors you depend on
Without timely business sign-off, the test phase tends to stretch, so agree on the approvers and the acceptance criteria early.
Can our own team upgrade ERPNext without a partner?
Yes, if your team has Linux, database and Frappe bench experience and time to test properly. The upgrade is a sequence of steps you can run yourself, but the risk sits in the details: companion apps split out in version 15, custom code that breaks, and reports or print formats that change. Decide by comparing your team's capacity and experience with the list of customizations and integrations you run. A partner is most useful when the scope is large, the timeline is fixed, or no one has rehearsed the rollback. DeployOpen plans, implements, customizes, hardens, backs up, upgrades and documents self-hosted platforms in your own infrastructure, so either path can be scoped in writing.
Does Frappe warranty still apply after we move to a new version?
Warranty coverage from Frappe depends on your subscription, not only on the version you run. According to Frappe's supported versions policy, customers must be on a listed version and subscribed to a matching Frappe Cloud support plan to receive warranty coverage from Frappe. Version 15 is planned to be supported until the end of 2027 and version 16 until the end of 2029, per the same page. If you self-host, confirm with Frappe which support plan, if any, matches the target version before you commit to a date, and record that answer in the project file.
What should a written quote for an ERPNext upgrade include?
A useful quote states the scope in terms you can check. Ask for the list of sites, companies, apps and custom code in scope, the target version (15 or 16), and the exclusions. Each deliverable should be named: test environment, migration runs, fixes to customizations, data validation, cutover runbook, rollback plan and handover documentation. Ask how testing is counted, who signs off, what happens if the scope changes, and how minor updates after go-live are handled. Confirm whether the price is fixed for the agreed scope and which items are optional, so you can compare offers on the same basis.
Should we move to version 15 or version 16 for the upgrade?
Choose based on support windows, your custom code and how much change your team can absorb. Version 15 is planned to be supported until the end of 2027 and version 16 until the end of 2029, according to Frappe's supported versions page. Version 16 gives you the longer runway, but it brings more changes for custom apps. Check each custom app against the version 16 requirements, confirm companion app availability, and ask for a test migration to both targets before deciding. Document the choice and the reasons in the project record so auditors and future maintainers can follow it.
What happens to our data during an ERPNext upgrade?
Data is migrated in place by the migration process, which is why a verified backup and a test copy come first. Each run should be checked against accounting totals, stock balances, open documents and key reports before anyone trusts the new site. Ask for the validation checks, the rollback point, and who holds the backups and their retention period. Keep the production site read-only or frozen during cutover if your process allows it, so that no transactions are lost between the final backup and the switch.
How DeployOpen scopes and delivers an ERPNext upgrade
The sequence turns an end-of-life ERPNext version 14 site into a written upgrade plan, a tested target on version 15 or 16, and a production cutover with a documented way back. Each step ends with an artifact the client can check.
Inventory the site and its apps
DeployOpen collects the bench version, installed Frappe and ERPNext branches, companion apps such as Frappe HR, Lending, Payments or India Compliance, custom apps, customizations, scheduled jobs, integrations and the database size. The client confirms which business processes depend on each item. The step closes with an inventory document that lists every app, its current branch and its owner, so no component is left out of the plan.
Choose the target version in writing
Version 14 reached end of life on January 31, 2026, so the choice is between version 15, which is planned for support until the end of 2027, and version 16, planned for support until the end of 2029, according to Frappe's supported versions page. DeployOpen compares the choice against the client's custom apps, compliance needs and support horizon, then records the decision and the reasons in the scope. Confirm current support terms directly with Frappe before signing.
Build a test environment from production
DeployOpen restores a recent production backup into a separate environment that matches the production hosting method, whether bench on Linux, Docker with frappe_docker, or Kubernetes. Secrets, outbound email and payment or bank connectors are disabled or pointed at sandboxes so test runs cannot affect live partners. The step closes when the client confirms that the copy matches production data and configuration closely enough to test against.
Run the staged migration and fix breaks
DeployOpen installs the target-version branches of ERPNext and each companion app, runs the migrate step, and works through breaking changes such as apps split out of the core, print formats, reports, and custom scripts. Server Scripts are disabled by default from version 15, so any dependent logic is reviewed and re-enabled deliberately. Each fix is logged against the inventory item it resolves. The step closes with a clean migration on the test environment and a list of accepted changes.
Verify accounting, stock and integrations
DeployOpen and the client run scripted checks against the upgraded test site. Typical checks compare ledger totals, stock balances, open invoices and outstanding payments with pre-upgrade figures, and confirm that each integration, login method and scheduled job behaves as before. The client signs off test cases for the processes it runs daily. The step closes with a signed verification record that defines what passed and what was accepted as a known difference.
Rehearse cutover and rollback
DeployOpen writes the production cutover runbook, including a fresh backup, the maintenance window, the migrate sequence, and the restore procedure if verification fails. The rollback path is rehearsed on the test environment, and the restore is timed so the client knows the recovery sequence before it is needed. The step closes with an approved runbook and a rollback test record.
Cut over production and document the result
DeployOpen runs the approved runbook on production, repeats the verification checks, and hands over the site with its final app list, configuration changes and open items. Documentation covers how to run future minor updates with bench update and which backups to keep. The step closes when the client accepts the cutover in writing and the handover document is filed with the site's operating records.
Agree ongoing support in a retainer
Once the site is live, the client can keep DeployOpen on a retainer for minor updates, security patches, monitoring of frequent releases and periodic restore tests. The retainer scope, response expectations and review cadence are written into the agreement rather than assumed. The step closes when the retainer scope is signed, or when the client decides to run updates with its own team using the handover document.

