Java CMS: content choices for a maintained retail site
Choose a Java CMS approach around the supported runtime, editorial task and public delivery, with clear commerce boundaries and maintenance owners.
- Published
- Last updated
Choose a Java CMS that fits your supported runtime and lets editors publish the retail content your application needs. Use CMS-rendered pages when the CMS can own the public presentation. Use API-delivered content when your existing application must keep control of rendering and commerce.
A shared language doesn’t make two applications compatible. The decision is where content runs, who publishes it and how a correction reaches the customer.
Identify the application and runtime
Record the deployed Java version and application framework before assessing a CMS. Include the application server, deployment package, content repository and the team responsible for updates. Compare the requirements of the exact proposed releases, including custom modules.
Magnolia is a maintained Java CMS with both templating and content-delivery options. Its certified stack lists Java 17 as the build base for Magnolia 6.4 and Jakarta EE 10 as its baseline. The same documentation distinguishes supported application servers from those Magnolia certifies through testing.
That distinction changes an embedded proposal. Sharing a Java version with your store application doesn’t establish matching servlet requirements or compatible dependencies. A CMS deployed beside the application can have its own supported runtime. An application reading content over an API doesn’t load the CMS into its own process.
Write the deployment choice into the proposal. Specify whether the CMS renders public pages, runs as a separate service or genuinely becomes part of the existing application. Require an upgrade path for the selected combination. An old integration article isn’t evidence that the current versions work together.
Editors also need a usable route into the system. Identify staff sign-in, network access and the permissions needed to edit a guide or approve a policy correction. A working developer login doesn’t prove that the content team can complete its job.
Work the retail content task
Compare CMS-rendered and API-delivered content using the same buying guide and policy correction. Magnolia can illustrate both approaches, so the comparison doesn’t need to change the editorial product as well as the architecture.
Consider an illustrative outdoor retailer. An editor maintains a waterproof-jacket buying guide. Several category pages reuse the returns policy, and each guide links to products through stable catalogue identifiers. The content team corrects an inaccurate returns statement once.
With Magnolia templating, the CMS owns the guide’s page presentation. The implementation must resolve the reusable policy record wherever the template displays it. The retailer’s commerce application remains responsible for current product facts and transactions.
With the Magnolia Delivery API, a separately maintained application reads structured content and renders the guide. The delivery endpoint supports reading content and querying records. Your application owns how those results become pages, including missing fields and content references.
Ownership in the jacket example
| Record or behaviour | CMS-rendered arrangement | API-delivered arrangement |
|---|---|---|
| Buying guide | Editor changes CMS content, rendered through CMS templates | Editor changes CMS content, rendered by the retail application |
| Reusable returns policy | Template resolves the approved policy record | Application resolves the approved policy record from delivery content |
| Catalogue reference | Template connects a stable product identifier to commerce data | Application connects the same identifier to commerce data |
| Stock and price | Commerce source supplies the current values | Commerce source supplies the current values |
| Basket and order | Commerce application authorises the transaction | Commerce application authorises the transaction |
Keep a product’s description in the agreed catalogue source if that source already owns it. A guide can explain which jacket suits a use without creating another stock or price record. A corrected policy must reach every page that uses it, including any public content read by a shopping assistant.
Verify publication and access
Follow the returns correction from an editor’s draft to the anonymous public page. A preview must show the proposed wording without making the draft available to shoppers. Approval and publication must use the intended staff roles.
Magnolia’s publishing module handles publishing between instances. In the API arrangement, publishing the record and refreshing the retail application are separate responsibilities. A successful CMS publication doesn’t prove that an application cache or generated page now contains the correction.
Use this acceptance sequence in a non-production environment:
- Edit the shared returns record and preview it with the buying guide and category page.
- Confirm an editor without publishing permission cannot release the correction.
- Publish through the approved role, then request both pages without a staff session.
- Compare the displayed policy version with the published record. Refresh any application cache or generated output through the configured publication process.
- Restore the previous approved version and confirm the public pages follow the recovery process.
For API delivery, apply both endpoint and repository permissions. Magnolia’s REST security documentation describes these separate access checks. Keep authoring access separate from the public content endpoint. A browser must never need a publisher’s credentials to display the guide.
Expected failure behaviour
| Condition | Required public result | Owner of the response |
|---|---|---|
| Missing guide record | A real missing-page response or an explicitly designed alternative | Template or retail application maintainer |
| Failed content request | A controlled error or a permitted saved version, with an operational alert | Application and content-service operators |
| Unpublished draft | The previous published version remains public | CMS permissions and publication owner |
| Stale public page | Version mismatch triggers investigation and refresh | Cache or generated-page owner |
For the policy correction, agree whether serving an older saved version is acceptable. If the previous wording is materially wrong, continuing to serve it can be worse than temporarily removing the affected passage.
Compare complete operation
Compare the full operating arrangement under one workload. For example, price one retail site with six editors, a separate approval role and guide pages delivered through the existing application. Include the public instances and non-production environments that arrangement needs.
Magnolia’s licence documentation states that each DX Core instance requires a licence. Some extensions require separate licences. Specify the edition and included modules in the proposal, especially where preview or approval depends on an extension.
Assign a named owner to each operating duty before accepting either architecture:
- The CMS maintainer owns product and module updates, plus repository recovery.
- The application team owns API consumption, rendering and the public refresh process.
- The infrastructure operator owns runtime patching, monitoring and recoverable backups under the hosting agreement.
- The content owner controls publication permissions and confirms restored policies are correct.
Include implementation support and a recovery exercise in the cost comparison. Backing up content alone doesn’t restore templates or application configuration. An API arrangement also needs the delivery configuration and consuming application restored together.
Choose CMS-rendered pages when your team wants the CMS to own presentation and can maintain its deployment. Choose API delivery when the existing application must own the public experience and its team can support the extra publication step. Ask each proposal to demonstrate the same policy correction and recovery before committing to the architecture.
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.