Guide 05 · Developer docs

Content types and custom entities

Which built-in type fits which purpose, how categories, tags, slugs, custom URLs and SEO settings behave across them, how revisions and publishing gate what the public sees, how to model a domain the platform has no type for, and where uploaded files live.

L1–L3
Unit 03 · Revisions, publishing and approval

Edit locks and concurrent editing

When two people open the same record in the admin, the Edit locks setting decides whether the second is told, kept out or neither. This page covers each mode, how a lock is released, why scripts ignore locks, and what a team that keeps colliding should change.

Who this is for. Site builders and team leads whose authors overwrite each other's changes, and developers whose scripts write records that people may have open. After this page you can choose the right mode, and tell a configuration problem from a working-practice one.

The four modes

The setting is "Edit locks" (Globals.admin.editLocks). When an author opens a record to edit it, the admin takes a lock on it for that user. What happens when a second author opens the same record depends on the mode:

OptionKeyA second author opens the record
DisableddisabledNo lock is taken; the feature is off.
Display editing user; do not lock (the default)displayThe admin shows who else is editing. The second author gets a lock too, and both can save.
Disable edit button; do not prevent direct accessdisableButtonThe admin hides the edit button. Nothing on the server enforces it: an author who reaches the edit screen directly gets a lock and can save.
Strict: Forbid parallel record editingstrictNo lock is given while another lock exists. The admin reports who holds it and offers no edit.

In every mode but Disabled, reopening a record you already hold renews your lock instead of adding a second one.

Scripts and integrations ignore locks

The setting's help text says "Edit locks to not affect API requests", and that holds in every mode, Strict included. A script or integration writing through the API can overwrite a record that an author has open in the admin.

How a lock is released

  • Saving releases your own lock.
  • While the edit screen stays open, the admin renews the lock periodically.
  • A lock that is not renewed for 60 seconds expires. Expired locks are swept away whenever locks are next looked up, so closing the tab without saving frees the record within about a minute; nothing has to be released by hand.
  • In Strict mode only, the admin also offers to force the release. It removes every lock on the record, whoever holds it.

Enforce edit locks

A second setting, "Enforce edit locks" (Globals.admin.enforceLocks), has help text that reads "users cannot save changes when they do not have an active lock on the record." What an editor can do when another user holds the lock follows the Edit locks mode above: in Strict, a second author cannot take a lock while the first is active, so there is no edit screen to save from; in Display or Disable edit button, the second author takes a lock of their own and can save alongside the first, whatever Enforce edit locks is set to.

When a team keeps colliding

With the default mode, two authors can both save the same record, each from the content they opened, so one author's changes can replace the other's. Display and Disable edit button warn rather than prevent, so a team that keeps losing work this way usually needs a change in how it works:

  • One owner per record at a time. Agree who is editing what, and save and close a record instead of leaving it open.
  • An approval workflow for records many people change. Restrict editing in the review step to one group, so changes arrive in a branch and are reviewed before they replace the live version; see Approval workflows: steps, transitions and approvals.
  • Scripts kept away from records people are editing. API writes ignore locks, so run bulk updates when nobody is editing, or on records nobody edits by hand.

The technical change that does alter behaviour is switching Edit locks to Strict. It is blunter: the second author is kept out until the first saves or the lock expires.

Go deeper

Was this page helpful?

Your answer goes to the docs team.