Open edX upgrades and support

Open edX supports only its latest named release, so every operator must upgrade on the release cycle. This page explains what an upgrade and support engagement covers, what drives its cost and duration, and what your team must provide.

On this page

Open edX upgrades and support: why every operator must keep moving

This service covers planning and carrying out upgrades for a live Open edX site as it moves through named releases, plus support after go-live, all inside your own cloud accounts, data centers or private networks. Teams can run upgrades in-house or hand the work to a partner, and the choice usually depends on how much custom code the site carries and how much release testing capacity the team has. The timing is fixed by the project itself: Open edX states that the latest named release is the only supported release and that it cannot support more than one release at a time. A site that stays on an older release falls outside that support, so every operator is working against a schedule they did not set.

Four kinds of events should start an upgrade assessment. The first is a new named release. Verawood is the current named release, published on 30 July 2026, and the next releases, Willow and Xylon, are listed for December 2026 and June 2027. Release dates and status can change, so confirm the current position in the Open edX release notes on the day you read this. The second is a Tutor version change. Tutor is the Docker-based distribution most operators use to run Open edX, and a new Tutor release can change configuration, container images and the plugin hooks your site relies on. The third is a security issue in the platform or one of its dependencies, which may leave little time to wait for a planned window. The fourth is a broken plugin, theme or XBlock after an update, which shows that custom code has drifted from the release it was built against.

Before any upgrade starts, the team needs an inventory of what the site runs. List every Tutor plugin, custom XBlock, theme, frontend plugin slot and Django plugin, along with the identity provider, LTI tools and analytics components connected to the LMS and Studio. Verawood, for example, added a new Studio sidebar, a redesigned instructor dashboard, an AI Extensions Framework, tagging and taxonomy management, new frontend plugin slots and LTI Advantage Complete certification. Each of these can affect course authors, instructors or integrations, so confirm which changes matter to your staff before the test environment is built. Back up the MySQL and MongoDB data, media storage and Tutor configuration first, and write a rollback plan that names who makes the call to revert.

Support after go-live covers a different set of decisions. Ask a partner which releases and Tutor versions the support covers, who applies security patches, who owns the test environment, and how quickly they respond to a broken plugin. A fixed-scope upgrade project and an ongoing retainer are separate purchases. The project is typically one-time work for a defined release change, while a retainer recurs and covers monitoring, patches and later upgrades. A quote should list the target release, the plugin and XBlock inventory being tested, the environments included, the number of upgrade cycles covered and any exclusions, such as remediation of custom code that the platform change breaks. Those lines tell you what you are paying for and what you still need to plan for internally.

What an Open edX upgrades and support engagement includes

An Open edX upgrade moves the whole stack, including the platform, Tutor, and every custom XBlock, plugin, theme and integration, onto a release that Open edX still supports. The cards below follow that path from assessment through handover, then the support that continues after go-live. Each work package produces evidence the client keeps, so the next upgrade starts from a documented baseline.

Upgrade assessment

We record the current Open edX release, the Tutor version, and every custom component running on the platform. We then map the gap to the target named release, noting which Python, Node.js, MySQL, MongoDB and Redis or Memcached requirements change. Open edX supports only the latest named release, so the assessment fixes the path before any work starts. The client should check that every custom component has a named owner and a current source location.

Production-mirroring test environment

We build a staging environment from the same Tutor configuration, database engine versions, cache setup, media storage and plugin set as production, using a recent copy of data with learner personal data handled under the client's own policy. A test environment that differs from production hides the problems that matter most during an upgrade. The client should confirm where this environment runs, who can access it, and how it is removed after sign-off.

Upgrade execution through each release step

Where the platform must pass through intermediate named releases, we run and verify each step in order rather than jumping ahead. For each step we apply the Tutor version change, run database migrations, rebuild frontend assets and check the LMS and Studio before moving on. The client should ask for the exact release sequence in the quote and the rollback point at each step.

Regression testing of custom components

We test custom XBlocks, Tutor and Django plugins, themes, frontend plugin slots and external integrations such as SSO and LTI against the target release. Each component gets a test list covering course authoring, learner delivery, grading and the integration handshake. Failures are logged with the component, the release step and the fix applied. The client should confirm which tests already exist, since missing tests are the main driver of testing effort.

Post-upgrade handover

We transfer the working system to the client's operations team with the runbook, updated configuration, component inventory and a walkthrough of the new release. The handover covers how to run the next upgrade and which custom components need attention because of the release changes. The client should confirm who receives access, who signs off the change, and how knowledge transfer is recorded.

Support after go-live

After go-live, support covers triage of platform incidents, monitoring of the components we changed, applying security updates to the supported release, and advice on planned changes to custom code. Coverage levels, response expectations and what counts as in scope are defined in the written agreement. Support is available as a retainer, so the client should ask for the service levels and the upgrade cadence in writing before signing.

What makes an Open edX upgrade take longer or cost more

This table lists the factors that change how much work an Open edX upgrade involves, why each one matters and what to do to keep it contained. Read each row against your own installation, since effort follows from the written scope and not from any single factor alone. The main takeaway is that custom code, configuration drift and untested integrations usually weigh more than the version gap itself.

DriverWhy it mattersHow to keep it down
Named releases between current and targetOpen edX supports only the latest named release, so each skipped release adds changes to review, test and reconcile. Verawood is the current named release, and Willow and Xylon are listed as the next two.Upgrade on a regular cadence rather than letting the installation fall several releases behind. Ask the partner to map release-by-release changes against your scope.
Number and age of custom XBlocks, plugins and themesCustom code written against older APIs is the most common source of breakage after a release. Each block, plugin and theme needs its own compatibility check and fixes.Keep an inventory with owners and versions. Retire unused blocks, prefer documented plugin slots and hooks, and remove forks of core code where possible.
Tutor configuration driftSettings edited by hand on servers, or spread across several config files, make it hard to know what the running system needs. Drift turns an upgrade into an investigation.Keep all configuration and plugin lists in version control. Confirm the running configuration matches the repository before starting an upgrade.
Number of integrations (SSO, analytics, LTI)Each identity provider, analytics pipeline and LTI tool has its own settings, certificates and data flows that must keep working after the upgrade.List every integration with its endpoint, owner and test steps. Ask for each one to be verified in staging before cutover.
Number of environmentsEach environment, such as development, staging and production, needs its own upgrade run, configuration check and sign-off. Gaps between them cause surprises at go-live.Limit the environment count to what you need. Promote the same tested configuration through each environment instead of rebuilding them separately.
Hosting model (single Tutor host or Kubernetes)A single Tutor host has fewer moving parts but requires careful downtime planning. A Kubernetes cluster adds rollout ordering, shared services and scaling checks.Document the upgrade procedure for your model. Ask the partner to state whether the quote assumes a single host or a cluster.
Depth of test coverageWithout automated tests for custom code and key learner paths, every upgrade relies on manual checks, which take longer and miss more defects.Add automated tests for custom blocks, plugins and critical course flows. Agree a written acceptance test list before the upgrade starts.

What support after go-live covers and what it does not

Ongoing support for an Open edX platform falls into three different kinds of work, and the difference matters when you decide what to buy. Incident response is unplanned work triggered when something breaks, such as the LMS returning errors to learners, Studio becoming unavailable to course teams, or a worker queue stalling. Routine maintenance is scheduled work that keeps the running platform healthy, such as patching, certificate renewal and backup checks. Planned upgrades are larger, scoped changes that move the platform to a newer Open edX named release or a newer Tutor version. Each has a different urgency, a different owner and a different price basis, so ask any partner to show how each is handled in writing.

Routine maintenance on a Tutor-based platform starts with monitoring. The scope should name the LMS, Studio and the background workers, with checks on process health, error rates, queue depth for asynchronous tasks, database and cache availability, and disk use on the media and log volumes. Ask who receives alerts, who is on call outside business hours, and what the platform owner is expected to do when an alert fires. Security patches are applied to the release you run, which is the only release that receives them, so the maintenance scope should state how patches are tested on a staging copy before they reach production and who approves each change.

Backup verification is one of the most overlooked parts of routine support. A backup that has never been restored is an assumption, not a recovery plan. The support scope should specify which databases and file stores are backed up, how often restores are tested, and who performs the restore test and records the result. Configuration changes are a separate category. A partner can advise on settings in the Tutor configuration, on the cache and database layout, or on logging, but the decision to change production configuration should stay with your change process, with the advice and the reasoning recorded.

Plugin breakage after a Tutor update deserves its own line in the scope. Tutor plugins, custom XBlocks and themes are the most likely components to fail when the underlying distribution moves forward. Support should cover diagnosing which component broke, repairing it within the agreed scope, and reporting what was changed. Support does not normally include rewriting a custom feature that the current release no longer accommodates, because that is development work. Ask whether a fix for a plugin break is covered by the retainer or quoted separately, and how the boundary is drawn.

DeployOpen offers ongoing support, upgrades and continuous testing as retainers. The scope, the response expectations and any service levels are agreed in writing before the retainer starts, and they should be checked against your own internal obligations before you sign. Ask for the written definition of what counts as an incident, what counts as routine work, what is excluded, and how additional work is requested and quoted. Service levels are not stated here because they depend on the agreed scope and on your environment.

How an Open edX upgrade runs from assessment to handover

An Open edX upgrade moves a live platform from its installed named release to the current supported one in controlled stages. Each phase produces a written artifact that the next phase depends on, so the client can see what changed, why, and who owns it at every point.

  1. Inventory the installed platform and assess the gap

    Engineers record the installed Open edX named release, the Tutor version and its configuration, and every custom XBlock, plugin, theme and frontend change. They also list external integrations such as SSO providers, LTI tools and analytics pipelines, plus the data volume in MySQL, MongoDB and media storage. The installed release is compared with the current supported release, since Open edX supports only the latest named release, and the upgrade path through each named release in between is identified. The step closes with a signed-off inventory that names each custom component, its owner, and whether it needs changes. Ask for this inventory as the first deliverable in any quote.

  2. Build staging from a production copy

    The team builds a staging environment inside the client's own infrastructure from a recent copy of production. Staging matches production on Tutor version, release, plugins, theme and configuration, with secrets handled under the client's own standards. Integrations are pointed at test endpoints so that no learner emails, grade passbacks or SSO callbacks reach live systems. The client confirms which data copies its policies allow in a non-production environment before the copy is made. The step closes when a configuration comparison between staging and production shows only intentional differences, and that comparison is documented.

  3. Write the step-by-step upgrade plan

    The team writes an upgrade plan with one stage per named release between the installed version and the target. Each stage lists the Tutor and platform steps, plugin version changes, database migrations, settings changes, and the rebuild or retest of custom XBlocks and themes. Each stage has entry and exit checks and a rollback point. The plan also records decisions the client must make, such as retiring a custom feature that will not be carried forward. The step closes when the client's technical owner approves the plan in writing and the stage order is fixed.

  4. Run functional and regression tests

    Each upgrade stage runs on staging and is tested before the next stage starts. Functional checks cover enrollment, course authoring in Studio, learner course play, assessments, certificates, the instructor dashboard, SSO login, LTI launches and analytics event capture. Regression checks cover custom XBlocks, plugins, theme pages and integrations that worked before the upgrade. Defects are logged, fixed and retested. The step closes with a test report that shows pass or fail for each case, with any open defect accepted in writing by the client. Load testing is scoped separately if the client needs it.

  5. Cut over production with a rollback plan

    Before cutover, the client and the team agree on a change window, freeze content changes, and define the criteria that trigger a rollback and who makes that decision. Fresh backups of MySQL, MongoDB, media storage and configuration are taken. The upgrade then runs in production following the tested plan, and smoke tests are run before traffic is treated as live. The rollback steps are rehearsed from those backups and the rollback point is kept until the client signs off. The step closes with a cutover record showing timestamps, smoke test results and the retained rollback point.

  6. Hand over the runbook and support

    The team delivers a runbook covering the architecture, the Tutor commands in use, backup and restore procedures, the upgrade procedure for the next named release, ownership of each custom component, monitoring and escalation contacts. The runbook must also flag the next release the platform will need to reach, such as Willow, which is listed for December 2026. Engineers walk the client's operations team through the runbook and transfer access. If a support retainer applies, the scope of incident response, upgrades and continuous testing is agreed in writing. The step closes with a signed runbook, a recorded knowledge transfer and a support hand-off record.

What goes wrong when upgrading Open edX and how to prevent it

Open edX upgrades rarely fail in the platform code alone. The risks sit in the customizations, configuration and integrations wrapped around it, and they surface during a release jump or a Tutor version change. Each card below names one failure pattern and the control that keeps it from reaching your learners.

Custom XBlocks and plugins break on new releases

Custom XBlocks, Django plugins and Tutor plugins depend on internal APIs that can change between named releases. A block that renders correctly on your current release can fail on import or at runtime after the upgrade. Pin each plugin to a known version, record which Open edX release it was built for, and run every custom block through a regression pass in staging before any production change.

Frontend changes alter themes and slots

Newer releases change Studio and LMS frontends, including the new Studio sidebar and the redesigned instructor dashboard in Verawood, and they add frontend plugin slots. Theme overrides and swizzled components can silently stop matching the markup they replace. Keep branding inside supported theming hooks and plugin slots where possible, and check each custom override against the release notes before you upgrade.

Migrations run without a tested backup

Upgrades apply database migrations to MySQL and MongoDB, and some of them cannot be reversed by a simple rollback. Taking a backup is not enough: the restore has to be tested on a copy of production data, with the restore time measured and the media storage included. Confirm with your operator which backup tooling and retention you will use, and write down the point at which you would restore rather than roll forward.

Skipped releases compound breakage

Open edX supports only the latest named release, so a deployment that skips one or more releases must absorb every intervening change at once. Each skipped release adds migrations, deprecations and configuration keys that the next one assumes. Plan upgrades as a sequence of named releases with a staging run at each step, and confirm the target release against the Open edX release notes before scheduling.

Hand-edited Tutor configuration is lost

Tutor generates its configuration and environment files from the config it holds, and changes made by hand inside generated files can be overwritten on the next render or update. Settings then revert without warning, often for SSO, email or storage. Keep every override in Tutor configuration or a plugin, store it in version control, and keep a written configuration baseline so you can diff the rendered result before and after an upgrade.

Integrations stop working after a change

Single sign-on, LTI tools and analytics pipelines depend on settings, certificates, endpoints and event formats that a platform change can alter. A SAML metadata update, a changed OAuth2 redirect URI or a new Aspects event schema can break logins or data flow with no error on the LMS home page. Test each integration end to end after every upgrade, including a real login, a graded LTI launch and an analytics event reaching its store.

Recurring costs for Open edX upgrades and support after go-live

This table compares the cost components that continue after an Open edX launch, who pays for each one, whether it is one-time or recurring, and what changes it. The platform is AGPL-licensed and Tutor is open source, so the recurring spend sits in infrastructure, internal time, testing, custom code and any support arrangement you choose. Use it to build the cost questions you will put to a partner or to your own team.

Cost componentWho paysOne-time or recurringWhat changes it
Open edX software licenceNo license fee, the platform is AGPL-licensedNot applicableConfirm any vendor subscription or support option directly with the vendor
Staging and production infrastructureYour organization, through your cloud account or data centerRecurringNumber of environments, LMS and Studio sizing, database and cache tiers, storage for media and backups
Internal team time for approvals and testingYour organization, through staff or a partnerRecurring, per release cycleNumber of named releases you adopt, number of custom XBlocks and plugins, number of stakeholders who sign off
Release upgrade projectsYour organization or a partner, under a fixed-scope or time-and-materials agreementOne-time per upgrade, recurring over the platform's lifeDistance between your current release and the latest supported release, and how much custom code must be ported
Tutor version upgradesYour organization or a partnerRecurringTutor plugin compatibility, changes to your configuration, and how often you pin and review versions
Testing tools and test environmentsYour organization, through tool licenses or open-source toolingRecurringRegression test coverage, automated versus manual checks, and the number of browsers and learner paths you verify
Maintenance of custom XBlocks, plugins and themesYour organization or a retained partnerRecurringNumber of custom components, how closely they track platform changes, and whether frontend plugin slots are used instead of forks
Retainer or support feesYour organization, to a service providerRecurring, optionalResponse expectations, scope of upgrades included, and whether testing and monitoring are covered
Backups, monitoring and incident responseYour organization, through staff or a partnerRecurringRecovery expectations, hosting model, and how often you restore and test backups

How upgrades differ by starting release, hosting model and customization

An installation several named releases behind cannot jump straight to the current release in one step. Because Open edX supports only the latest named release, the work becomes a sequence of upgrades through each intermediate release, with testing and a backup before every step. The number of steps and the size of each gap drive most of the effort.

  • Release path: List every named release between the installed version and the current release, and confirm the order each step must follow.
  • Data migrations: Each step may change the MySQL and MongoDB schemas, so plan a restorable backup before each one.
  • Custom code drift: Plugins and XBlocks written for an old release may fail at each step, and the failures may appear only after the next step.
  • Dependency changes: Python, Node.js and database version requirements can shift between releases, which affects the build image at each step.
  • Verification: Run learner and course-team flows on staging after each step, not only at the end.

Client provides: the installed release and version, the configuration and deployment repository, backup access and a staging environment that matches production. Ask for the full intermediate release list in writing before agreeing on effort, since the path determines the work.

What your team must provide before an upgrade or support retainer starts

Before any upgrade or support retainer starts, your team needs to hand over a defined set of access, artifacts and decisions. Without them, the first weeks of the engagement go to discovery instead of testing, and the change window slips. The list below is what we ask for at the start. Each item has one owner on your side, and each owner should be named in writing before work begins. Administrative access comes first. The implementer needs administrative access to the hosting environment (cloud accounts, data center hosts or the air-gapped network where the platform runs) and to the Tutor configuration, meaning the environment files, the list of enabled plugins and the settings that define your deployment. The owner is your platform or infrastructure lead. Ask them to confirm which accounts can grant access, how credentials are issued and whether any access must be logged or time-limited under your own policy.

Next, you provide a current backup and a copy of the deployment repository. The backup must be recent enough to restore the LMS and Studio databases, the MongoDB content store, media files and any object storage that holds course assets, and your team should test a restore of it before the engagement starts. The repository should hold the Tutor project and any local customization, with a record of the commit that is running in production. The owner is typically the platform lead, with the database administrator confirming restore steps. If no recent backup exists, the first task is to create one and verify it, and that adds time to the schedule.

You also supply an inventory of custom XBlocks, plugins, themes and integrations. This list is the basis of the compatibility assessment, so it should name each item, its source (in-house code, a vendor package or a community plugin), the version or commit in use, the person who last changed it and any external system it calls, such as an SSO provider, a payment gateway or an LTI tool. Gaps in this inventory are the most common reason an upgrade estimate changes after kickoff. The owner is usually the lead developer for the platform, with the business owner of each integration confirming it still matters. Items nobody can name should be flagged as a risk rather than dropped silently. Business owners approve test results, and this decision must sit with named people, not a shared mailbox. Assign one owner for learner-facing flows, one for course authoring and Studio, and one for each integration that carries grades, enrollments or identity. Each owner signs off on the test cases that cover their area and on the go-live recommendation. Agree in advance how long a sign-off takes and who decides if an owner is unavailable: a named deputy with equal authority should hold the decision, and if no deputy exists, the release waits rather than proceeding on silence.

Finally, you provide a test account set and sample courses, a change window agreed with the teaching calendar, and a decision on who receives alerts. Test accounts should cover each learner role, instructor, course team member and administrator, and should include enrollments in sample courses that use the XBlock types you rely on. The teaching calendar owner, usually an academic or program operations lead, decides which dates are closed to change, including exam periods and cohort starts. Alert recipients are owned by the operations lead, and you should confirm an escalation path for out-of-hours incidents. If the operations lead is unavailable during scheduling, the window should default to a period that the teaching calendar already marks as quiet, and that choice should be recorded before the retainer begins.

Questions buyers ask before hiring help with Open edX upgrades

How much does an Open edX upgrade cost?

The cost follows from the written scope, and a fixed-scope quote is issued once that scope is agreed. The main drivers are the number of named releases being crossed, the number of custom XBlocks, plugins and themes that must be retested, the size of any Tutor version change, how many environments (development, staging, production) are involved, and whether SSO, analytics or Kubernetes are part of the deployment. Most of the cost is one-time project work. Ongoing support or upgrade cover can be added as a retainer. Ask any quote to list each custom component, the environments covered, the testing scope, the cutover approach and what is excluded. DeployOpen does not publish a price list.

How long does an Open edX upgrade take?

Duration depends on how much code and configuration must change and how much testing the changes need. The biggest factors are the number of releases crossed, the amount of custom code and frontend work, Tutor version jumps, database migration size, whether a staging environment mirrors production, how quickly the client can sign off test results, and any constraints on the cutover window. A credible schedule comes after an inventory of the existing deployment. Ask for milestones tied to the agreed scope, with named client decisions and test sign-offs marked, so you can see where time is most likely to move.

Can our own team upgrade Open edX without outside help?

Yes, if your team has working skills in Django, Docker and Tutor and enough time to test. Upgrades touch settings, container images, configuration and any custom code, so the work is more than a version bump. Check that someone owns regression testing of courses, assessments, certificates and SSO, that a staging environment mirrors production, that backups have been restored successfully at least once, and that a rollback plan exists. If any of these are missing, the main risk is an outage during cutover. A short dry run on a copy of production is a practical way to find out where your team stands before committing.

How often do Open edX upgrades need to happen?

You need to upgrade whenever the release you run is no longer the latest named release, because Open edX states that only the latest named release is supported. Verawood is the current named release, published on 30 July 2026. The next releases, Willow and Xylon, are listed for December 2026 and June 2027, which are six months apart. Plan for a regular upgrade cycle that follows those dates, and check the release notes for final dates before you set a schedule. Tutor version upgrades run on their own timeline and should be planned alongside platform releases.

What does the client need to provide for an Open edX upgrade?

The work needs access, information and people. Provide access to the Tutor configuration repository, the secrets and environment variables used in each environment, and the staging and production infrastructure. Share an inventory of custom XBlocks, plugins, themes and integrations, plus the backup and retention policy. Name a decision-maker who can sign off test results, and identify course owners who will check their own content after the upgrade. Confirm the maintenance windows allowed for cutover. Agree these items in writing before work starts, because gaps here are the most common cause of schedule changes.

What happens if we skip an Open edX release?

You fall further behind, and the work to catch up grows. Open edX supports only the latest named release and cannot support more than one at a time, so a skipped release is one the community no longer supports, and fixes for it are not guaranteed. Each skipped release adds changes that must be migrated and tested together, which raises effort and risk. Custom XBlocks, plugins and themes written against an older version may need rework. A catch-up plan should size each intermediate change, the testing it needs and the order of upgrades, so the team can decide how far to go in one project.

How DeployOpen scopes, delivers and supports Open edX upgrades

DeployOpen scopes Open edX upgrades as written projects with a fixed scope agreed before work starts. We plan each move through named releases, since Open edX supports only the latest release, and we test custom XBlocks, plugins and themes against the target before any production change. Ongoing support after go-live is available as a retainer.

How we scope

  • The written scope names each source release, target release and Tutor version involved in the upgrade.
  • Custom XBlocks, Tutor plugins, frontend plugin slots and themes are inventoried with owners and compatibility notes.
  • Quotes state which environments, hosting model and handover documents are included, and which are excluded.

How we build

  • Upgrades are rehearsed on a staging copy of the LMS, Studio and databases before any production change.
  • Custom XBlocks, plugins and themes run through automated and manual checks against the target release.
  • Database migrations, configuration changes and Tutor version steps are recorded as a repeatable runbook.

How we hand over

  • Handover includes an upgrade runbook, rollback steps and a record of every custom component and its version.
  • Your team receives documentation for configuration, secrets handling and where custom code lives.
  • Walkthroughs cover the release calendar, so your team can plan the next upgrade using the same runbook.

How we support

  • Support after go-live is available as a retainer covering support, upgrades and continuous testing, agreed in writing.
  • Retainer terms state response expectations and upgrade windows up front, so both sides know what to expect.
  • Ask whether the retainer includes release upgrades, custom component regression testing and security testing.

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.