Ruby on Rails CMS: editorial and delivery choices
Choose a Rails CMS approach around the actual editor, content model and publication path, with retail transactions kept in their owning system.
- Published
- Last updated
A Ruby on Rails CMS can keep editing inside your Rails application or supply content from a separate service. Choose an embedded CMS when your Rails team wants to own the editor and rendering together. Choose a remote CMS when editors need a separate workspace and the application can manage content retrieval and refresh.
Either arrangement can let staff update guides without releasing application code for every edit. The deciding test is whether an approved change reaches the customer page while drafts stay private.
Define the Rails editorial task
Start with the Rails and Ruby versions your application actually runs. Read them from the application’s dependency lockfile, then compare the chosen CMS release’s requirements with that combination. A project’s development branch and its released gem can have different requirements. Rails also has its own maintenance policy, so compatibility with an old application doesn’t establish ongoing security support.
Give an editor a representative job before choosing the software. For example, ask them to revise a mattress-care guide, reuse a care instruction across two pages and submit the change for approval. Identify who can edit, who can publish and who manages the content model. A login screen alone doesn’t establish that those permissions are separate.
Model a guide with a stable identifier, title, slug, body and publication state. Store reusable advice as a referenced record when editors must change it once across several guides. Keep product references as catalogue identifiers that the application resolves. Prices, stock and checkout rules stay with the systems that already own those transactions.
For a hypothetical mattress guide, an editor owns the explanation of firmness. The catalogue owns each mattress’s current price and availability. A discontinued product reference needs a defined replacement or omission rule, so the guide doesn’t promise an unavailable item.
Compare Rails content arrangements
Alchemy CMS is a concrete embedded candidate. Its project documents an editor with live preview, page versioning and user access control. The 8.4 stable branch’s gem specification requires Ruby 3.1 or later and Rails components from 7.2 up to, but excluding, 8.2. Use the selected released gem’s requirements for installation decisions. Don’t infer support for every newer Rails release from the project name.
With an embedded engine, your team deploys CMS code and database changes alongside the application. Routine content edits can happen through the editor after installation. You still own authentication integration, backups and upgrades. Alchemy uses a BSD licence, so assess hosting and engineering work separately from licence cost.
Contentful is a remote alternative with an official Ruby client for its Content Delivery API. Editors work in Contentful, while Rails retrieves published records. Its Preview API uses separate credentials to retrieve drafts. A preview route must therefore use the preview source deliberately and remain separate from public delivery.
The remote service reduces the CMS code you host inside Rails, but it adds an external content dependency. Compare the selected Contentful plan’s roles, usage limits and subscription terms with the number of editors and expected delivery traffic. Keep application integration and cache-refresh work in the budget too. A remote CMS subscription doesn’t implement your Rails preview route or publication handler.
Compare the work each arrangement creates
| Requirement | Embedded Alchemy CMS | Remote Contentful |
|---|---|---|
| Editing | Editor runs within the Rails CMS arrangement | Editors use a separate content workspace |
| Preview | Documented live preview, integrated with your templates | Rails preview route reads the separate Preview API |
| Access | Integrate the application’s user model and CMS access rules | Choose service roles and restrict application credentials |
| Deployment | CMS upgrades share the application’s release work | Application code and content-service configuration have separate release paths |
| Cost | Licence plus hosting, backups and developer maintenance | Service plan plus integration, usage and application maintenance |
Prefer the embedded path when your team can maintain the engine and needs editing close to Rails templates. Prefer the remote path when the editorial workspace must also supply other sites or applications. For the wider architecture decision, the CMS frameworks guide compares content arrangements across application stacks.
Check public delivery and recovery
Trace one approved record through every layer that can keep old content. For an embedded arrangement, follow the published database record into the Rails renderer and its fragment or low-level caches. For a remote arrangement, follow the published API response into any local copy, background job and rendered response. Include the content delivery network if it caches HTML.
The Rails caching guide explains fragment caching and record-based cache versions. A remote content change won’t update an unrelated Rails record automatically. Include the content revision in the relevant cache dependency, or expire the affected entry through your publication handler.
Run this acceptance sequence in a test environment using a guide with an identifiable sentence.
- Save a draft change. The editor preview must show it while a signed-out visit still shows the published text. Check that the public response contains neither draft text nor preview credentials.
- Publish the approved record. Trace its identifier and revision through the delivery path. Open the public route in a fresh session and confirm the body and linked product references match that revision.
- Make the content source unavailable. Confirm the application follows its chosen fallback, such as retaining the last approved guide. An empty response must not silently replace that copy.
- Interrupt publication or its refresh job. Restore the service and retry the event. The customer page must reach the approved revision without duplicated content or unrelated cache deletion.
- Restore the previous approved content revision and refresh its dependent caches. Confirm the previous wording returns publicly and the later draft remains available only to authorised editors.
If the CMS shows the new text but the customer page doesn’t, compare the published source revision with the revision Rails rendered. A mismatch at the source points to publication state or environment selection. A correct source with old HTML points to a local copy or cache that missed the change.
Choose the arrangement only after an editor can complete that path with their actual permissions. Keep the record identifier and expected revision with the publication check, so the next failed update has a specific place to investigate.
Give your store its own shopping agent
Customers ask in their own words. Your agent finds, compares and checks out from your catalogue, right on your site.