Editorial Drupal permissions audit showing editorial jobs mapped to roles, reviewed in a permission matrix, tested and approved

Editorial illustration; the roles, permissions and user interface are representative examples, not a live Drupal site.

Drupal permissions are easy to postpone because a new site often has only one administrator. The problem appears later: an editor needs to publish, a translator needs to update one language, a contributor needs to upload media, and the fastest answer is to give everyone a powerful role. That shortcut makes the site difficult to reason about and increases the impact of a compromised account or an ordinary mistake.

This guide is for a Drupal site owner or technical lead who wants a repeatable permissions review. The aim is not to create the smallest possible permission list. It is to make every access decision explainable, testable and maintainable.

Summary

  • Start with real editorial jobs, then map those jobs to roles and permissions.
  • Review permissions provided by enabled modules and remove access the team does not need.
  • Test each role on staging with both allowed and denied actions, including the anonymous visitor view.
  • Record the reason, owner and review date so the matrix does not become forgotten configuration.

1. Inventory users, roles and enabled modules

Export or record the current roles, assigned users and enabled modules before changing anything. Include custom modules and workflows, not only the modules the team remembers installing. A permission may have been added for a feature that no longer exists, or a module update may have introduced a new permission that nobody reviewed.

Do not start by deleting roles. First create a baseline that lets you compare the result and restore a decision if a publishing task stops working.

Drupal’s official guidance describes permissions as capabilities granted to roles. The practical implication is that a role is not a job title by itself; it is a bundle of actions that should match a real responsibility.

2. Write the jobs in ordinary language

List tasks rather than people:

  • draft and edit an article;
  • publish an article after review;
  • upload an image and edit its metadata;
  • manage a translation;
  • moderate comments;
  • manage users;
  • change configuration;
  • install or update extensions.

Then assign an owner to each task. “Marketing team” is too broad to test. “Content editor can edit and submit articles for review but cannot change site configuration” is a useful boundary.

This step also exposes tasks that should not belong to ordinary editors. Configuration changes, extension installation and user administration deserve a separate review because they can affect the whole site.

3. Build a permission matrix

Create a small table with roles in columns and actions in rows. Mark each cell as allow, deny or not applicable, then write a short reason for every allow. Avoid copying a role from another site: the installed modules and content model may be different.

The matrix should answer questions such as:

  1. Can this role create content?
  2. Can it edit any content or only its own content?
  3. Can it publish directly, or must it use moderation?
  4. Can it see private files or user data?
  5. Can it change configuration or grant access to another account?

If nobody can explain why a permission is enabled, treat that as an audit item rather than an automatic reason to remove it in production.

4. Keep the anonymous visitor boundary visible

Check what an unauthenticated visitor can view, submit and discover. A permission review that only tests logged-in roles can miss an exposed view, form or file. Use a private browser window or an equivalent anonymous test, and check pages that contain unpublished, private or access-controlled content.

This is also where you verify the difference between “can see a page” and “can administer the content behind the page”. The visitor path and the editor path should both be intentional.

5. Separate content work from site administration

Editors usually need to create or update content, not manage modules, fields, views or user accounts. Giving an editor a broad administrative role may make a one-off task easier, but it makes future changes harder to review.

Use a separate, tightly controlled role for configuration work. If one person must perform both jobs, document when elevated access is used and remove the extra assignment when the work is finished. A role that combines everything is convenient but difficult to audit.

For sites with a formal review flow, connect permissions to moderation states rather than assuming that everyone who can edit should be able to publish. The workflow in Drupal Content Moderation: A Practical Editorial Workflow shows why review state and user access solve different problems.

6. Test allowed and denied actions

For each role, create a short test script. It should include one action that must work and one that must fail. For example, a translator can edit the translated field but cannot change site configuration; an editor can submit a draft but cannot publish it without review.

Test more than the menu. A hidden link is not the same as a denied operation. Try the action directly on staging, record the response and check that an error does not reveal information the role should not see.

Never test destructive permission changes first on production. Use a staging copy with representative roles and content, then repeat a small smoke test after deployment.

7. Review custom permissions and module changes

Contributed and custom modules can add permissions that are easy to overlook. After enabling or updating a module, read its permission labels and decide which roles, if any, should receive them. A permission with a vague label deserves extra attention because the label may not explain the data or configuration it exposes.

Keep a change note with the module version, permission changed, reason and tester. This becomes valuable during a security review or when an editor asks why a task suddenly stopped working.

8. Remove stale assignments carefully

Review users who have left, changed jobs or no longer need elevated access. Check shared accounts and temporary access separately; they are difficult to attribute and easy to forget. Prefer named accounts with the smallest suitable role.

Before removing a role, confirm that the user’s real work still has a path. A permission audit should reduce unnecessary power without creating a hidden operational dependency on one administrator.

Example: a three-role starting point

A small publishing site might start with Author, Editor and Administrator, then adjust based on actual tasks. Author can create content and save drafts. Editor can review and publish within the content workflow. Administrator handles configuration and account management. The exact permissions depend on modules and site design; the names alone are not a security control.

If the site needs translation or media governance, add those responsibilities deliberately rather than handing out the administrator role. Keep the matrix beside the deployment notes and review it when the content model or modules change.

Mistakes to avoid

  • Assigning administrator access because a user cannot find one needed task.
  • Assuming a hidden admin menu means an operation is denied.
  • Testing only the successful path and never checking a denied action.
  • Forgetting anonymous visitors, private files and unpublished content.
  • Leaving temporary or shared accounts in the permission matrix forever.

My Take

Permissions are part of the site’s operating design, not a box to tick once. The most useful matrix is not the one with the fewest permissions; it is the one a new maintainer can read and understand. I would rather keep a clear, slightly conservative role structure than rely on one powerful administrator who knows how everything works.

Conclusion

Inventory the current state, describe real jobs, build a reasoned matrix, test both allowed and denied actions, and review changes from modules and users. Keep the record with the site’s maintenance notes. A permission model that can be explained is much easier to secure and repair.

Sources