Open edX role-based access for course authoring

Open edX role-based access for course authoring lets you scope Studio permissions by course, organization or site instead of relying on older course-level roles. This page explains what the openedx-authz setup involves, how to migrate existing roles in controlled batches, and how to prepare for Willow.

On this page

Open edX role-based access for course authoring: when your teams need it

Enable openedx-authz when several course teams, faculties or partners need different authoring rights in Studio and you want those rights scoped by course, organization or site. The feature changes how Studio decides who may edit what, applying authoring permissions at those three levels instead of treating every course team the same way. Learners are not affected by this change, because it governs the people who build content, not the people who take courses. Open edX runs two core services that matter here. Studio (CMS) handles course authoring, and the LMS delivers courses to learners. Because the authorization change applies to Studio, you should test it against course creation, editing and publishing, not against the learner experience. Enabling it is an operator decision made per installation, so one choice applies to everything running on that installation. Confirm how it interacts with any multi-site or white-label setup you plan before you decide.

Enable it when you can name the problem it solves. Typical signals include a partner who must edit its own courses but not those of other partners, a faculty that needs to publish without touching another faculty's catalog, or an audit requirement to show who held authoring access and when. If every course team on your platform has the same rights, the current model may be enough, and the migration effort may not be justified yet. Write down which teams, courses and organizations need separate rights before you open a change request, and map each group to the scope it needs. Existing course roles do not disappear when you turn the feature on, so plan the migration as its own workstream. Move existing roles in controlled batches, starting with a small set of courses, verifying that each team can still author and publish, and only then moving the next batch. Keep a record of which roles moved in each batch so you can roll back a batch if a team loses access it needs. Ask your implementation partner or your own platform team to define the verification checks for each batch before the first one runs.

Plan around the release calendar. The Open edX release notes list Verawood as the current named release, published on 30 July 2026, and list Willow for December 2026. Open edX supports only the latest named release, so you will need to upgrade regardless of this feature. The release notes also indicate that authorization is planned to become the default in Willow. Before you schedule your migration, read the Willow release notes for the final default behavior, the migration steps and any breaking changes, and decide whether to enable the feature on your current release, wait for Willow, or do both in sequence.

Scope options for Studio roles and when each fits

This table compares the three scope levels for Studio roles (course, organization and site) by who usually holds each one, the risk of granting it too widely, and the admin work it creates. Read each row as a question to answer for your own staff before choosing a default. The main takeaway is that the narrowest scope that lets a team do its work is usually the safest starting point, and existing course-level roles should stay in place until each batch is verified.

ScopeWho usually holds itRisk if granted too widelyAdmin work it creates
CourseInstructors, course authors and teaching assistants on a single course runLow. Access reaches one course, but a single over-broad grant can still expose unpublished content or learner data for that courseHighest count of individual grants. Each course needs its own role assignments, so onboarding and offboarding touch many records
OrganizationDepartment or program leads who manage several courses owned by one partner, faculty or content teamModerate. One grant can reach every course under the organization, including courses staff should not edit yetFewer grants, but the organization structure must match real ownership. Reorganizing courses later means reviewing who holds which organization role
SitePlatform administrators and a small number of operations staff, not course teamsHigh. Site-wide reach touches every organization and course on the installation, so it should be limited to a few named peopleLowest number of grants, but each one needs a documented reason and periodic review, since site-level access is the hardest to audit by eye
Keeping existing course-level roles during a phased rolloutTeams already in a course role before the authorization changeRemoving them early can block active courses. Duplicating them at a broader scope before review can widen access without anyone deciding toPlan a checkpoint per batch: confirm the new scoped role gives the same working access, then retire the old role. Confirm with your Open edX version notes how existing roles are read during the transition
Confirming exposed scopes and role namesPlatform owner and the team that will run the authorization changeAssuming scope or role names from another release can lead to grants that do not do what the policy saysCheck the Verawood release notes and the openedx-authz project documentation for the exact scopes and role names available on your version before writing any policy

How openedx-authz scopes Studio permissions

The practical difference between role-based authorization and a per-course staff list is where the grant is made and where it is kept. In a per-course model, a person with course staff rights adds a named user to each course that user should author in, so the grant lives beside that course. With openedx-authz, access is expressed as a role assigned at a scope such as a course, an organization or a site, so one grant can cover many courses. Before you enable it, decide which team owns those grants, because that team controls who can widen access across the platform.

Three questions shape the rollout: who grants access, where the grant is recorded, and how it is checked when a user opens Studio. Confirm each answer for your release in the official documentation and on a test instance before you plan the migration. Ask your operations team to show you where the grants are stored, whether they can be exported for review, and how a lookup for one account is resolved. An auditor will ask the same questions, so the answers should be written down before the first batch of users moves.

Inheritance is where access mistakes usually hide. A role assigned at an organization or site scope may apply to the courses beneath it, but the reader should not assume this until it is verified in their own environment. Create a test user, assign a role at one scope, open courses at each level in Studio, and record what the user can and cannot edit. Then remove the role and repeat the check, because revocation matters as much as the grant. Do not rely on inherited access for any migrated batch until both tests pass.

Verawood changes the authoring surface these permissions govern. It added a new Studio sidebar, an AI Extensions Framework, and tagging and taxonomy management. Each is a place where an author takes action, so each needs a test account with a deliberately limited role. Check which sidebar entries, taxonomy actions and AI features appear for that account, and whether authors who should not use AI features can still see them. If a role does not hide a feature, plan a separate control for it and record that control as an open item before go-live.

Setup sequence for enabling role-based access in Studio

This sequence moves role-based access for Studio from a confirmed version record to a planned production change. Each step ends with a check, most often a comparison of effective permissions for a sample of courses before and after. The output is a tested scope model and a change plan that course owners and the platform team have both approved.

  1. Confirm the release and Tutor versions

    Start in a staging environment that matches production as closely as possible. Confirm which Open edX named release and which Tutor version include the role-based authorization for Studio, using the Open edX release notes and the Tutor documentation. Do not assume support from the feature name alone. The release notes state that only the latest named release is supported, so confirm that your target release stays in that line and note any upgrade it requires. Output: a written version record signed off by the platform owner.

  2. Inventory course roles and staff users

    Export every course team role, organization-level staff assignment and platform administrator account from production Studio and the LMS, and record which courses each person can reach. Include service accounts and anyone who gets access through a group or an external identity provider, since these often go uncounted. Confirm the export method against the Tutor documentation for your version, then check the export by hand for a sample of courses. Output: a dated inventory that the course owners and the platform team have both reviewed.

  3. Define the scope model by course

    Decide at which level role decisions are made: per course, per organization or per site. Map each course from the inventory to exactly one scope owner, and record which roles remain global. Review the model with course owners and the security lead before any setting changes, because scope determines who can edit a course after the switch. Check: every course in the inventory has one owner, and every role in the model has a documented reason to exist.

  4. Enable the feature in staging

    Before changing anything, capture effective permissions for the sample courses in staging so you have a baseline. Then apply the feature configuration through your Tutor project, following the Tutor documentation and the settings named in the release notes for your version. Keep the change in version control so the production change is the same reviewed diff. Restart the services Tutor reports as affected, then log in to Studio as a platform administrator. Check: Studio loads without errors and the sample courses still show the same content and team members.

  5. Verify permissions with test accounts

    Create one test account for each role in the scope model, with no extra grants. Run the same actions for each account against the sample courses in each scope: viewing the outline, editing content, managing the course team and publishing. Compare the results with the baseline captured in staging. Each difference should either match an intended change in the scope map or be recorded as a defect to fix before production. Output: a comparison table that the course owners have reviewed and approved.

  6. Plan the production change window

    Order the production batches from the scope map, moving lower-risk courses first and keeping a rollback path for each batch. Set the window length and the freeze rules with your own change process, and agree who can approve a rollback. Notify course teams before each batch. Check the Open edX release notes for the Willow date, listed for December 2026, and confirm whether role-based access becomes the default there before deciding how long to run the two models side by side. Output: a written change plan with a go or no-go check after each batch that compares effective permissions with the staging results.

Migrating existing course roles in controlled batches

Move existing course roles to the new scopes in small groups so that each group can be checked, and reversed if needed, before the next one starts. Group courses by the organization or owning team that manages them, because that is how the scopes for Studio will be drawn. Begin with a group that has a clear owner and few instructors who also work on other teams' courses. Verawood is the current named release, published on 30 July 2026, and Willow is listed for December 2026 as the release where this authorization model is planned to become the default. Confirm the exact behavior of the target release in its release notes before you plan the first batch.

Before any change to a batch, create a rollback point. In practice this means a backup of the MySQL data that holds role assignments, a copy of the site and course configuration in your deployment repository, and an export of every role assignment for the courses in the batch. Keep the audit list in a versioned file with one row per course and user. Record the role before the change, the scope after the change, the batch identifier and the approver. Rehearse the rollback in staging on the same batch. Ask your vendor or the release notes which tables and services store role data, so you know that a restore returns every assignment, not only the course-level ones.

Some assignments will not map cleanly to the new scopes. Illustrative examples include a contractor with instructor rights on courses owned by two organizations, a former staff member whose account still holds course staff rights, or a team lead who needs access to one course while the team's new scope is wider. Reconcile each case into one of three outcomes: assign the narrower scope, keep the assignment as a named exception with an owner and a review date, or remove it. Write every exception into the audit list. Do not let the automated mapping resolve these cases silently, because the audit list is the only record of why a user kept or lost access.

Each batch needs approval from three roles before it runs: the lead of the owning team for the courses in the batch, the platform operator who executes the change, and a security or compliance approver who reviews the exceptions. No batch proceeds until all three have signed the audit list for that batch. Keep the sign-off record with the rollback point so that an auditor or internal reviewer can trace each change from request to completion. Agree in writing who may approve exceptions and how long they may stay open.

The number of courses and users is the main driver of effort. More courses mean more batches, more owners to coordinate and more rehearsals, and more users mean more exceptions to reconcile. Test batch size in staging with a copy of production role data. Measure how long a batch takes to apply, verify and roll back, and count the exceptions it produces. Use those results to choose a batch size for production. When you ask a partner or internal team for a quote, ask for the batch count and size assumed, the number of staging rehearsals included, who performs the sign-off reviews, and what recurs after the migration, such as exception reviews.

Security risks when Studio access changes

Moving Studio to course, organization or site scoped roles changes who can edit content and who can reach course data. The risks below appear during enablement, during batch migration and when staff change roles or leave. Each card names the control that reduces the risk and what to check before the change goes live.

Over-broad site or organization grants

A site-wide or organization-wide grant lets one account edit or view unpublished content in every course under that scope. During migration, legacy staff roles can be mapped to broader scopes than the work requires. Apply least-privilege scope by default, grant organization or site roles only to central teams, and list every holder of those grants before go-live. Confirm in the openedx-authz documentation how each scope maps to Studio actions.

Orphaned roles after staff leave

Course roles remain in place after a person leaves the faculty, department or vendor unless someone removes them. A former instructor or contractor can keep editing access to unpublished drafts and course materials. Connect role removal to your offboarding process, and run periodic access reviews that compare active staff records with current course role holders. Confirm where the authoritative staff list lives and how often it is exported for comparison.

Audit gaps during batch migration

Batch migrations change many role assignments in a short window, and a gap in the record makes later questions hard to answer. Run each batch with a named list of courses, a snapshot of role assignments before and after the change, and a named approver. Keep these records outside Studio so they survive platform changes. Before relying on any platform log, confirm in the vendor documentation which role changes are recorded, and test that on a staging copy.

Studio permissions versus LMS data access

Studio roles control authoring, while learner records, enrollments, gradebook data and instructor views are governed by separate LMS permissions. A user may be able to edit a course yet reach learner data they no longer need, or the reverse may happen after a scope change. Map each Studio role to the LMS data it can reach, then test with one account per role in a non-production instance. Confirm which LMS views are affected by the new scopes in your release.

Untested role behavior before production

Scoped permissions can behave differently from the old course roles in edge cases such as shared libraries, imported courses and content used across several courses. Problems found in production are harder to correct because authors and learners are already working in the affected courses. Build a test matrix with one account per role and scope, run it against a staging copy of your data, and sign off each result before the production batch. Repeat the matrix before Willow makes this model the default.

Preparing for Willow, when role-based access becomes the default

Verawood is the current named Open edX release, published on 30 July 2026. Willow is listed for December 2026 and Xylon for June 2027. Willow is the release where role-based authorization becomes the default for Studio, so a platform that enables it on Verawood is preparing for a change that arrives whether or not the course migration is finished. Open edX states that the latest named release is the only supported release and that it cannot support more than one at a time. Once Willow is out, an installation still running Verawood will need an upgrade path to follow the default change, and that path will not wait for your role migration to finish.

Treat the Verawood work and the Willow upgrade as two projects with separate scope, owners and acceptance tests. The Verawood project enables the authorization layer for Studio, sets the scope at course, organization or site level, and migrates existing course roles in controlled batches. The Willow project moves the platform to a supported release and confirms that the authorization behavior your teams rely on still holds once the default changes. Keeping them apart lets you roll back a batch of role changes without also reversing a platform upgrade, and it stops the Willow date from being used as a deadline to finish a migration that was never tested.

Run the migration on Verawood first, in batches small enough that each course team can check its own courses. After each batch, confirm that instructors, course team members and staff can still open Studio, edit content, publish and manage course access, and that no user has lost a permission they need. Record the role mapping as a versioned document: each legacy course role, the authorization role it maps to, the scope it applies at (course, organization or site), any exceptions, and who approved them. This record is the main input to the Willow project, and it is the evidence an internal reviewer or external auditor will ask for.

When the Willow release notes are published, read them against your mapping before you set an upgrade window. Confirm the Willow change list yourself: which authorization behaviors change, which settings or defaults move, and whether any role your mapping depends on is renamed, removed or narrowed. Do not assume that Verawood test results carry over unchanged. If you ask a partner to quote the Willow upgrade, base the request on that change list, your current Tutor version, your custom plugins and the number of sites, so the quote reflects what your installation actually needs to change.

Limits to confirm in your environment before production

The supplied research establishes the release timeline and the general shape of Open edX authorization work, but it does not settle the details that determine whether role-based access fits your installation. The cards below list each open item, what to confirm, and who holds the answer.

Exact role names and definitions

The role names, their scopes across course, organization and site levels, and the mapping from existing course team roles are not established by the research for this page. Ask the project for the authoritative role list in the release you plan to run, then check it against a sample course in staging. Record the agreed names in your authorization design before migrating any course team.

Full permission list per role

Confirm the complete set of actions each role can perform in Studio, such as editing content, publishing, managing team members and viewing unpublished content. Compare the permission matrix in the release notes and project documentation with the permissions your course teams expect today. Any gap found here should be resolved with the project or a documented workaround before the first controlled batch.

Compatibility with custom Studio plugins and XBlocks

Custom Studio plugins and XBlocks may check permissions in ways that predate the new authorization model. Inventory every custom plugin and XBlock that reads course roles or enforces access, then test each one in staging with users holding the new roles. Ask your development team or the plugin maintainers which checks need updating and whether any require changes before the upgrade.

Behavior in multi-site installations

Confirm how role assignments scope across sites when one installation serves several branded sites, including whether a user with access on one site can reach another. Review the project documentation for site-level behavior and test cross-site access with a dedicated staging account. Coordinate this check with your multi-site design because a misconfiguration would expose course content across sites.

Interaction with LTI and third-party login

Verify how role data from identity providers, including OAuth2, SAML 2.0, Shibboleth and LTI sign-in, maps onto the Studio roles. Test a learner or staff login from each provider you use, and confirm that LTI launches do not grant authoring access unintentionally. Ask your identity team and the project maintainers to confirm mapping behavior before enabling authorization for externally authenticated users.

What does enabling role-based access cost, how long does it take and what does it need from us?

How much does enabling role-based access in Open edX Studio cost?

Cost depends on a written scope, so no figure is given here. The quote has two parts. DeployOpen's fees cover scope design, migration of existing course roles in controlled batches, testing and handover. Your team's time covers approving role mappings, confirming who should hold which role in each course, organization or site, and reviewing results.

One-time work is scope design, migration and testing. Recurring work is access reviews and Willow upgrade work, because the authorization model is planned to become the default in Willow, which is listed for December 2026. Ask the provider to split the quote by these phases so you can see what repeats over time.

What makes a role-based access project take longer or shorter?

The main drivers are the size of the scope and the state of your current role data. Count the courses, organizations and sites that will use the new authorization, and the existing role assignments that must migrate. Each batch is reviewed before the next one starts, so more batches generally means more calendar time.

Custom Studio plugins that check permissions add analysis and test cases. A staging environment that matches production lets batches be rehearsed, and without one testing takes longer and carries more risk. Testing depth is the last driver, since a light check of a few courses needs far less work than a full set of role checks across sites. No duration is given here, so ask for a schedule tied to the batch plan in the written scope.

Why does a staging environment matter for Studio role changes?

A staging environment lets your team rehearse each migration batch against a copy that resembles production before any course staff see changed permissions. Confirm that staging uses the same Open edX release, Tutor configuration, identity provider setup and course data shape as production, because a different setup can hide permission problems.

Without staging, batches must be tested on production or on a small sample, which usually forces smaller batches and slower progress. Ask whether your environment provides staging, who can access it and how data is refreshed. DeployOpen works inside your own infrastructure, so any staging environment is provisioned in your accounts or data centers as agreed in the scope.

Do custom Studio plugins change the effort for role-based access?

Yes, they can. Any plugin that checks course roles, instructor permissions or Studio menus directly may not follow the new authorization model and could behave differently after migration. Inventory each plugin, the permission checks it makes and whether it reads role data directly.

Plugins that rely on the old model need code changes, tests and sometimes coordination with their authors. Verify compatibility against the authorization module documentation for your release, and confirm the behavior in your own environment. Keep a current list of plugin versions so that Willow upgrade work can recheck each one.

Can our internal team enable role-based access without an outside partner?

Yes, a capable internal team can do it, but only with the right skills in place. You need people who can operate Open edX through Tutor, including Docker or Kubernetes depending on your deployment, and who can read Python and Django code to review plugins and the authorization change.

Someone must export and query existing course role data, often from MySQL, and understand how identity provider groups map to Studio roles. You also need a QA owner who can design test cases across courses, organizations and sites, plus an access approver who knows which staff should keep which roles. Check that the team has time for this work alongside normal platform operations. Edly, which maintains Tutor, offers professional support.

What do we need to provide before role-based access work starts?

Start with a current inventory: courses, organizations, sites, and every existing course role assignment with its owner. Add the custom Studio plugins and their versions, the identity provider setup that feeds group membership, and the Open edX release and Tutor version running in production.

Provide access to staging, or agree how one will be built in your infrastructure. Name the people who approve role mappings and sign off each batch, and set change windows that respect course teams' publishing schedules. Agree the depth of testing up front. This input feeds the written scope, which is agreed before work starts and is the basis for the quote.

What ongoing work follows enabling role-based access in Open edX?

Recurring work falls into two groups. The first is access reviews: periodic checks that Studio roles still match who teaches, edits or administers each course, organization or site, plus removal of access for departed staff.

The second is upgrade work. Open edX supports only its latest named release, and Verawood is the current one, so each move to a newer release, including Willow where the authorization model is planned as the default, means rechecking role behavior, plugins and tests. Confirm with your provider whether reviews and upgrade work are covered by a retainer or billed separately. DeployOpen offers ongoing support, upgrades and continuous testing as retainers.

How DeployOpen works on this

DeployOpen scopes Open edX role-based access for course authoring as a fixed-scope piece of work in your own infrastructure, with the Studio roles, course, organization and site boundaries agreed in writing first. The build runs on Tutor and is tested against your existing course roles before any batch moves. Ongoing support is available as a retainer for each named release.

How we scope

  • Written scope that names the authoring roles, course, organization and site boundaries in Studio you will enable.
  • An inventory of existing course roles, staff and instructor assignments, and the courses each one covers.
  • Batch plan for migrating course roles, with the order of batches and the rollback point for each.

How we build

  • Enable the openedx-authz authorization in the Tutor-based deployment on infrastructure you control.
  • Test permission outcomes for each role in a staging instance before any production course is migrated.
  • Confirm the target release and any openedx-authz compatibility notes published for it before the build starts.

How we hand over

  • Runbook covering role assignment, the migration batches run, and how to reverse a batch.
  • Test evidence from staging and production batches, kept in a form your audit team can review.
  • Knowledge transfer to your course operations and platform staff on who approves role changes.

How we support

  • Willow readiness review, since the openedx-authz model is planned to become the default in Willow, listed for December 2026.
  • Retainer options for upgrades to later named releases, covering authorization changes and course role checks.
  • Ask for a quote that separates one-time scoping and migration work from recurring support.

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.