Umbraco CMS and ecommerce: the retail setup
Review Umbraco CMS for a retail site. Separate content editing from commerce, compare hosting choices and define product, price and stock ownership.
- Published
- Last updated
Umbraco CMS gives a retail team control over content and page presentation. Selling through that site requires Umbraco Commerce or a connection to a separate commerce system. The architecture fits a team with .NET skills when its editorial needs justify building and maintaining those connections.
Start by naming the system that owns each product’s price and stock. That decision affects the buying guides editors publish, the basket customers use and the information supplied to customer-answer systems.
What the CMS controls
Umbraco CMS is the open-source .NET system for structuring and editing content. It also controls how that content appears on a site. Umbraco sells hosting and commerce as separate products.
Umbraco’s content modelling documentation calls the blueprint for a content item a Document Type. It defines the fields editors can complete and where that content belongs. A retailer can define a category guide with reusable advice fields instead of giving editors one unrestricted page of text.
Templates control how those fields appear to visitors. The CMS supplies the editing structure, but a field labelled price doesn’t establish a commerce pricing rule. A retailer still needs to decide what makes that price authoritative and how checkout receives it.
Umbraco’s pricing page lists the CMS itself as free. The site’s design, commerce implementation and operation still require a budget. Choosing the CMS doesn’t automatically buy those services.
Choose the commerce and integration approach
Umbraco Commerce is the official commerce add-on, while a separate commerce platform needs an integration with the CMS. Choose between those approaches before designing editable product pages.
The Umbraco Commerce product page describes store and order management inside the backoffice, alongside payment options and extensible interfaces. Its licensing documentation distinguishes unrestricted local development from public operation. A valid commercial licence removes the documented public-domain restrictions.
A proposal must also name compatible CMS and Commerce versions. The Commerce requirements document the platform and database dependencies for the selected version. Confirm the same combination for any added payment or shipping package before commissioning the store.
Define the retail connections
| Retail information or action | With Umbraco Commerce | With a separate commerce system |
|---|---|---|
| Product description and identifiers | Product content and the configured product adapter supply Commerce with product information | CMS content references the external product identifier through a defined mapping |
| Price and stock | Commerce property editors can hold prices and stock, or a designed integration supplies the designated source | The commerce or inventory source supplies these values to the site |
| Basket and checkout | The implementation connects basket actions and checkout to Commerce | The integration sends the correct product or variant to the external basket and checkout |
| Payment and orders | Configured payment providers and Commerce order processing handle the transaction | The commerce service handles payment and orders, with agreed status updates back to other systems |
Umbraco Commerce’s property documentation identifies product fields for the stock keeping unit (SKU), price and stock. The Umbraco Commerce product adapter converts a product information source into the format Commerce needs. That source can be Umbraco content or another system connected through a custom adapter.
A product reference and a SKU aren’t automatically interchangeable. Commerce’s complex variant documentation requires both product and variant references when adding a complex variant to an order. The implementation must preserve the particular option the customer selected.
For example, a fictional lighting guide might reference one desk-lamp product while the shopper chooses its brass finish. Map that choice to the store’s sellable variant. The guide, basket and customer-answer system must all identify the same finish, even if their internal records use different identifiers.
Supply price and stock from the designated commercial source. A product adapter connects data formats. It doesn’t by itself establish a reliable stock synchronisation process. Specify how changes arrive and what happens when an update fails. If the brass finish becomes unavailable, the guide can retain its advice while its buying controls reflect the agreed availability rule.
Commerce’s payment form documentation also distinguishes preparing an order from sending the customer to a payment provider. The proposed checkout must handle the provider’s response and the resulting order state. A published product page alone doesn’t prove that connection works.
Give editors a usable retail model
Build a content model around the decisions editors make repeatedly. Reusable fields help the retailer change advice without manually correcting every page that displays it.
Consider a fictional category-advice page for desk lighting. Its Document Type could have these fields and responsibilities:
- A page title and introduction owned by the category editor.
- Reusable advice blocks explaining task lighting and placement, approved by the retailer’s product specialist.
- Product references selected by the merchandiser, with a required sellable-variant mapping where the page promotes a specific finish.
- A link to the delivery policy owned by the operations team.
The template decides where those fields appear and how product panels are rendered. Changing a template can move the advice above the product panels without rewriting the advice itself. Changing a shared advice item changes its authored content wherever the implementation reuses that item.
Umbraco’s template guidance describes templates as Razor views tied to Document Types. The developer owns their rendering behaviour. A template change needs a release check, particularly if it changes how the page resolves a product reference.
Separate drafting from publishing access where the retailer needs approval. Umbraco’s user documentation describes user groups and permissions for backoffice access. Configure the allowed sections and content areas for each role. If the business needs approval stages beyond those permissions, include the workflow solution and its licence in the proposal.
Hosting and operational responsibility
Umbraco Cloud manages hosting functions, while a self-managed installation assigns those duties to the retailer or its provider. Both approaches leave the retailer responsible for the behaviour of its custom store.
The official Cloud and self-hosted comparison describes these operating choices. Compare who performs each task before comparing the subscription with a server bill.
Allocate the operating work
| Task | Umbraco Cloud approach | Self-managed approach |
|---|---|---|
| Deployment | Use Cloud’s environment workflow and agree who releases application changes | The provider or technical team builds and operates the release process |
| Updates | Cloud supplies automated update functions; the team still assesses custom code and packages | The technical owner schedules and applies platform and package updates |
| Backups and recovery | Cloud supplies backup and restore facilities; the team plans a complete store recovery | The provider must define backup coverage, retention and restore procedures |
| Access | Assign portal access separately from content-editor access | Manage hosting access alongside CMS and database permissions |
Cloud’s deployment documentation separates schema deployment from content and media transfer. Templates and Document Types follow the deployment process. Content editors can manage content through the backoffice without Cloud Portal access.
For Australian retailers, Cloud’s technical FAQ lists East Australia as a selectable hosting region and describes database and file recovery facilities. Choose the region for the actual project. That choice doesn’t establish where every connected payment, email or analytics service processes its data.
Put support hours and escalation in the contract. Australian hosting doesn’t promise Australian support hours. Match coverage to the store’s trading needs and name who handles a checkout failure outside business hours. Define who reconciles orders and payments if recovering the site requires restoring older data.
Decide whether the architecture fits the team
Choose Umbraco when the team has .NET maintenance skills and needs a content model that standard store pages don’t supply. Detailed buying guides and shared editorial content can justify that work. An existing commerce system can remain the transaction owner if the integration has clear responsibilities.
A retailer with a small catalogue and standard checkout can find a hosted commerce platform simpler to operate. Compare the included store functions and support with the full Umbraco implementation. Adding a managed CMS host reduces infrastructure work, but it doesn’t remove custom commerce integration.
Scope content modelling and frontend development separately from commerce configuration. Include product data preparation, payment integration and the customer-answer feed. The operating estimate must identify hosting and commerce licences, as well as support and future upgrades. Agree who pays for integration changes when either connected system changes.
Before approving the architecture, ask the implementation team to demonstrate two small acceptance cases in a test environment.
- Change the delivery policy through the permitted editor role. Confirm the published page shows the change and that any customer-answer system receives the revised policy through its intended update process. Confirm the editor can’t change payment configuration.
- Change the brass lamp variant’s price and availability in its designated source. Confirm its guide panel and basket use the correct variant and commercial values. Complete a test payment, trace the resulting order and exercise the failure path when the source update doesn’t arrive.
Record the expected result and the responsible person for each failed step. Choose the architecture once the team can show that an editorial change stays under editorial control and a product update reaches the buying journey reliably.
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.