Umbraco CMS

Umbraco CMS is a mature, open-source content management system built on ASP.NET Core that has powered over 750,000 websites since its initial release in 2004. It gives developers complete freedom over markup, data structures, and integrations while providing editors with an intuitive drag-and-drop backoffice interface for managing content, media, and multilingual publishing workflows.

At its core, Umbraco follows a composer-based architecture where every feature—from routing to caching to content delivery—is registered through a composable DI system built on top of Microsoft’s standard abstractions. This makes the CMS fully treatable as a framework: teams can replace, decorate, or extend virtually any internal service without forking the core. Content types, document types, media types, and member types are all defined through a schema-first model that maps cleanly to C# strongly typed models.

Umbraco ships a dual-surface API: a traditional Razor-based rendering pipeline for server-side template rendering, and a full headless Delivery API (OpenAPI-documented) for driving React, Next.js, Nuxt, or native mobile frontends. The backoffice itself has been rebuilt from scratch as a modern web components application using Lit and Vite, making it independently deployable and extensible through a manifest-driven extension model.

The project is actively maintained by Umbraco HQ and a large community, targeting .NET 10 and supporting both SQLite (for development and small deployments) and Microsoft SQL Server (for production). It runs on Windows, Linux, and macOS via the dotnet CLI, making it a practical choice for teams wanting the power of a full CMS without the operational overhead of a proprietary platform.

What You Get

• A schema-first content modelling system with Document Types, Media Types, and Member Types that generate strongly typed C# models for compile-time safety
• A headless Delivery API (OpenAPI 3.0 documented) for serving content to React, Vue, Next.js, or native mobile clients alongside traditional Razor rendering
• A modern web-components backoffice built with Lit and Vite, extensible through a JSON manifest system that lets packages register dashboards, sections, property editors, and actions without modifying core
• Multi-language and domain-per-culture support with variant content, allowing a single content tree to serve different languages with independent publishing workflows per culture
• A HybridCache for published content that stores the content tree in-memory for fast reads and in the database for distributed scenarios, with event-driven cache invalidation
• Full composability via ASP.NET Core DI—every service, repository, cache refresher, and content finder can be replaced or decorated by third-party packages or application code
• Built-in user and member management with configurable roles, permissions down to the node level, and external OAuth provider support through ASP.NET Core Identity
• Dual database support with EF Core migrations for both SQLite (development/single-server) and Microsoft SQL Server (production/multi-server), switchable via connection string

Common Use Cases

• Corporate and marketing websites — Marketing teams use the structured content editor and multilingual publishing to manage multi-brand, multi-region website presences without developer involvement for day-to-day updates
• Headless CMS backend — Development teams configure Umbraco as a pure content API, serving structured JSON to Next.js or Nuxt frontends while editors continue working in the familiar backoffice
• Intranet and member portals — Organisations deploy Umbraco with its built-in member management and per-node permission system to build authenticated portals with role-based content access
• E-commerce content layer — Agencies integrate Umbraco with commerce platforms (Shopify, Vendr, uCommerce) to manage editorial content, landing pages, and product descriptions in a single CMS while product data lives in the commerce system
• Government and public sector sites — Public sector teams choose Umbraco for its full control over output markup (enabling accessibility compliance), on-premises hosting, and audit-log tracking required for public accountability
• Multi-site agency platform — Digital agencies host multiple client websites on a single Umbraco installation using its domain and culture routing, reducing infrastructure overhead while keeping editorial environments isolated

Under The Hood

Architecture Umbraco uses a layered, composer-driven modular architecture on top of ASP.NET Core. The core separation runs across four tiers: Umbraco.Core defines all domain contracts, entities, and service interfaces without any infrastructure dependency; Umbraco.Infrastructure implements those contracts against the actual database, file system, and cache; Umbraco.Web.Common connects the CMS to ASP.NET Core middleware, request pipelines, and Razor rendering; and the API projects (Delivery and Management) expose OpenAPI surfaces independently. Components register into the runtime through the IComposer and IUmbracoBuilder patterns, which wrap the standard Microsoft DI container with ordered, weight-based composition. The HybridCache for published content is a particularly deliberate design: reads always come from an in-process memory structure (avoiding serialization overhead) while writes flow through the database-backed cache and trigger distributed cache refresher notifications so multi-server deployments stay consistent. Content finders and URL providers plug into the routing pipeline as ordered collections, making it straightforward to override how URLs resolve to content without touching the core.

Tech Stack The server side is C# on .NET 10, hosted as a standard ASP.NET Core application. Data access uses a dual-ORM strategy: EF Core with code-first migrations handles the schema lifecycle for both SQLite and Microsoft SQL Server, while the legacy persistence layer (NPoco-influenced) still underpins some repository paths. Lucene.NET via Examine powers full-text search indexing. Media processing uses ImageSharp for image transformation and resizing. The backoffice front-end has been fully rewritten as a web components application using Lit, compiled with Vite and TypeScript, built as a set of independently loadable packages discovered through a JSON manifest system. The REST APIs are documented via NSwag-generated OpenAPI 3.0 specifications. CI runs on Azure Pipelines with unit tests (xUnit), integration tests against real SQLite and SQL Server instances, acceptance tests via Playwright, and benchmarks via BenchmarkDotNet.

Code Quality The codebase has extensive test coverage across three tiers: unit tests, integration tests that run full DI containers against real database providers, and Playwright-driven end-to-end acceptance tests for the backoffice. Nullable reference types are enabled project-wide with nullable warnings promoted to errors, providing strong compile-time null safety across the entire backend. The build configuration enforces XML documentation generation, meaning public API surface is documented at the type level. An .editorconfig and StyleCop-derived rules enforce naming conventions and formatting consistently. The front-end client enforces TypeScript strict mode, ESLint with lit-specific rules, and Prettier formatting, with circular dependency checks and module boundary analysis as part of the build pipeline. The overall quality posture is high: the combination of nullable enforcement, multi-tier testing, and consistent linting reflects the maturity of a codebase maintained by a dedicated engineering team over two decades.

What Makes It Unique Umbraco’s most distinctive technical choice is its extension manifest system for the backoffice: packages register UI contributions (dashboards, property editors, sections, context menus) through a JSON manifest file that Umbraco discovers at startup, without any compilation step or framework-specific plugin API. This turns the backoffice into an open platform where community packages and customer code integrate at the same level as built-in features. The composer and collection builder patterns in the backend achieve a similar effect for server-side extensibility—any ordered collection of handlers, finders, or resolvers can have items inserted, removed, or reordered by downstream code without modifying the registering assembly. The dual-surface content delivery model (Razor rendering and headless Delivery API from the same content tree, same schema, same backoffice) with no additional licensing cost is uncommon in the .NET CMS space, and the migration from NPoco to EF Core while maintaining SQLite and SQL Server parity demonstrates a willingness to evolve foundational infrastructure without breaking the extension ecosystem.

Self-Hosting

Umbraco CMS is released under the MIT License, which is one of the most permissive open-source licenses available. You can use it commercially, modify the source code, redistribute it, and build closed-source products on top of it without any copyleft obligations. There are no contributor license agreements that would restrict your ability to fork the project, and no usage-based restrictions regardless of traffic, revenue, or number of editors. The license applies to the CMS core; third-party packages from the Umbraco Marketplace have their own licenses.

Running Umbraco yourself requires a functioning .NET 10 SDK and runtime, a SQL Server or SQLite database, and a web host capable of running ASP.NET Core applications—either IIS on Windows, Kestrel behind a reverse proxy on Linux, or a container runtime using the official templates. The CMS installation is a standard NuGet package, so initial setup via the dotnet CLI takes minutes. Operationally, you are responsible for database backups, schema migrations on version upgrades, certificate management, load balancer sticky sessions or distributed cache configuration for multi-server deployments, and monitoring application health. The HybridCache requires careful distributed cache configuration in clustered environments to prevent stale reads. Upgrades between major versions require running EF Core migrations and occasionally addressing breaking changes in the backoffice extension API, which Umbraco documents in version-specific migration guides.

Umbraco HQ offers a managed cloud product called Umbraco Cloud, which handles hosting, automatic upgrades, environment management (development, staging, production), Git-based deployment pipelines, and CDN integration. Compared to self-hosting, Umbraco Cloud removes the operational burden of infrastructure provisioning and upgrade management, but introduces a monthly subscription cost that scales with the number of environments and content volumes. The company also sells Umbraco Heartcore, a pure headless SaaS CMS, and offers enterprise support contracts that include SLA-backed response times, dedicated success managers, and priority access to the development team—none of which are available on the free self-hosted tier outside of community forums and the public issue tracker.