Kentico vs Umbraco: Architecture, TCO & Migration Guide (2026)

Kentico vs Umbraco: Architecture, TCO & Migration Guide (2026)

Kentico is a commercial .NET digital experience platform (DXP) that bundles CMS, marketing automation, email, personalization, and commerce into a single licensed product. Umbraco is a free, open-source .NET CMS that provides a content-editing core you extend with third-party tools. Both run on C# and SQL Server. The decision between them is fundamentally about cost model, operational responsibility, and whether you need an integrated DXP or a composable foundation.

If you are evaluating these two platforms in 2026, the catalyst is almost certainly a looming end-of-support deadline. Kentico Xperience 13 reaches full end of support on December 31, 2026. Umbraco 13 reaches end of life on December 14, 2026. Teams on older versions of either platform face a forced upgrade — making this the moment engineering and marketing leaders re-evaluate their CMS architecture.

This guide compares architecture, licensing, total cost of ownership, and the practical realities of migrating data between the two — based on vendor documentation, public pricing, G2 review data, NuGet package statistics, and direct technical analysis of both platforms' database schemas.

What is Kentico in 2026?

Xperience by Kentico is a content management system, digital commerce, and digital experience platform that combines CMS, digital marketing, and e-commerce features with a hybrid headless architecture. It is the successor to Kentico Xperience 13 — a complete rewrite released officially in 2023, designed as a SaaS-first, cloud-native platform.

Kentico is built on ASP.NET Core and uses Microsoft SQL Server for data storage. Since version 31.0.0, Kentico recommends running projects on .NET 10.

Xperience by Kentico uses a per-channel licensing model, allowing organizations to purchase only the digital channels they need — such as web, email, or headless channels — and scale over time. Two licensing tiers are available: Standard and Advanced.

The key draw is consolidation. A Kentico subscription unlocks content management, marketing automation, email campaign management, personalization, and headless delivery. In late 2025, Kentico introduced AIRA, a set of AI tools within the platform. In 2026, Kentico expanded AIRA with the Agentic Marketing Suite, including agents that can automate content optimization for SEO and AI search.

End-of-support deadline: Kentico Xperience 13 reaches end of support on December 31, 2026. After this date, Kentico no longer provides hotfixes, security patches, or technical support. Existing Xperience 13 projects continue to run, but as unsupported software.

What is Umbraco in 2026?

Umbraco is an open-source content management system built on the .NET framework and written in C#. The core CMS is MIT-licensed and free to use, deploy, and modify. You pay only for managed hosting (Umbraco Cloud), commercial add-ons (Forms, Commerce, Workflow, Deploy), or paid support.

Current version landscape:

• Umbraco 17 is the current Long-Term Support (LTS) release, supported until November 27, 2028. It runs on .NET 10 LTS.
• Umbraco 18, released June 2026, is a Short-Term Support (STS) release with end-of-life in June 2027.
• Umbraco 13 reaches end-of-life on December 14, 2026.

Teams still on v13 must upgrade to v17 or migrate to a different platform before that date. The jump from Umbraco 13 to 17 is a milestone upgrade — it involves migration to a fundamentally new backoffice rebuilt on Lit/web components. This is not a minor version bump.

Unlike Kentico, Umbraco ships no built-in marketing automation, email tools, or commerce module in the core product. Its composable architecture means you choose and integrate your own tools via open API layers. Umbraco provides a Content Delivery API for headless and decoupled frontends, a Management API for programmatic content management, and webhooks to notify external systems when content changes.

Ecosystem size: Umbraco has approximately 220,000+ active installations globally, over 500 packages on the Umbraco Marketplace, and the core repository has ~4,000 GitHub stars with active contributions from both the HQ team and community. The Umbraco.CMS NuGet package consistently ranks among the top .NET CMS packages by download volume.

How do Kentico and Umbraco differ architecturally?

Both platforms run on .NET and SQL Server. The difference is in philosophy and operational model, not framework.

Composable vs. integrated: what the distinction actually means operationally

"Composable" and "integrated" are vendor marketing terms that carry real operational consequences:

• Integrated DXP (Kentico): One vendor, one contract, one support escalation path, one roadmap dependency. When Kentico ships a breaking change, it affects your CMS, marketing automation, and commerce layer simultaneously. When you need a feature, you wait for their roadmap or configure what exists. Integration matrix is zero — everything already talks to everything.

• Composable CMS (Umbraco): You own the integration matrix. HubSpot, Mailchimp, Algolia, Salesforce — each is a separate contract, a separate API integration, and a separate failure point. You gain best-of-breed tool selection and vendor independence. You pay in engineering time: initial integration, ongoing maintenance, and version compatibility across the stack.

Neither model is inherently superior. The right choice depends on whether your team's bottleneck is budget and control (favoring Umbraco) or developer overhead and marketing self-service (favoring Kentico).

Multisite and multilingual architecture

This is a decision variable that generic CMS comparisons consistently omit, and where real architectural differences surface.

Kentico multisite: Built on a channel model. Each website is a separate licensed channel. Channels share a content repository but have independent URL configurations, personalization rules, and page builder templates. Adding a new site means adding a new channel license — a direct cost implication. Multilingual content uses culture variants per content item, managed per channel, with language fallback chains configurable in the admin.

Umbraco multisite: A single Umbraco installation supports multiple content trees under one backoffice. Site separation is handled by domain assignment in the content tree — no additional license fee per site. This makes Umbraco significantly cheaper for organizations running 5–20 related sites (brand families, regional microsites, campaign sites). However, template and code separation between sites requires disciplined architectural planning. Multilingual content uses culture-specific content variants; shared properties render once regardless of language, reducing duplication but requiring careful Document Type design.

Practical implication: A 10-site network on Kentico means 10 channel licenses. A 10-site network on Umbraco means one installation. The TCO gap for multisite organizations is materially larger than the single-site comparison suggests.

Database schemas and content storage

Understanding how these platforms store content is critical for performance tuning and future migrations.

Kentico uses a strict, highly relational database schema. Content is split across several tables:

• CMS_Tree — site structure and node relationships
• CMS_Document — culture-specific metadata and publication state
• CONTENT_[TypeName] — custom flat tables generated per Document Type (e.g., CONTENT_Article, CONTENT_Product)

This flat-table approach makes raw SQL queries fast and schema-transparent. Joining CMS_Tree, CMS_Document, and CONTENT_Article gives you a complete record in a single query. The cost: adding a field to a content type generates a schema migration — an ALTER TABLE statement — requiring database access and a deployment.

Umbraco uses an Entity-Attribute-Value (EAV) model. Data is recorded as three columns — entity (page), attribute (field name), value (content) — rather than one column per field:

• umbracoNode — content hierarchy and metadata
• umbracoDocument — publication state and culture flags
• umbracoPropertyData — all content values as key-value pairs, regardless of content type

EAV allows unlimited custom fields without schema changes. Editors and administrators can add fields in the backoffice without touching the database. The cost: EAV structures are inherently slow for direct SQL querying. A query that returns a fully hydrated content item requires multiple joins across umbracoNode, umbracoDocument, umbracoPropertyData, and umbracoPropertyType.

Umbraco solves the EAV performance problem with NuCache — an in-memory cache serialized to disk that stores pre-built content snapshots. Front-end rendering queries NuCache, not SQL. Cold-start performance depends on cache warmup time; under normal operation, NuCache makes EAV invisible to end users. If you attempt to extract data directly from Umbraco's SQL tables without using the APIs or NuCache layer, your queries will require complex multi-table joins that are highly prone to missing data or returning stale values.

Performance implications: For sites under ~100,000 content items, both architectures perform comparably in production. Umbraco's EAV becomes a material concern in very large installations (500,000+ nodes) where NuCache memory footprint and rebuild times become operational considerations. Kentico's flat tables perform consistently at scale but require careful index management on custom content tables as field counts grow.

Page building and editorial experience

Both platforms have moved away from rigid, form-based content entry toward visual, component-based page builders.

Kentico uses a Page Builder based on MVC widgets. Editors drag and drop .NET ViewComponents onto predefined zones within a template. Widget configurations are serialized as JSON and stored in the database. Xperience by Kentico has refined this into a polished, marketer-friendly interface — developers define the component boundaries; editors configure within those boundaries.

Umbraco handles visual editing via the Block Grid Editor (the successor to Grid Layouts, introduced in v10, default in v17). Block Grid stores layout and content data as a single JSON blob within a umbracoPropertyData record. Editors get a flexible drag-and-drop experience. Developers must parse complex nested JSON payloads on the front end, typically using strongly-typed models generated from the Umbraco content type definitions.

Migration implication: When migrating away from Umbraco, the Block Grid JSON is often the most difficult engineering hurdle. The JSON structure interleaves layout metadata with content values in a format specific to Umbraco's rendering pipeline. It cannot be lifted and moved to another platform without parsing, flattening, and restructuring the data.

How does pricing compare: Kentico vs Umbraco?

Xperience by Kentico licensing

Kentico does not publish dollar figures on kentico.com. Third-party pricing trackers report self-managed licensing from approximately $990/month and SaaS plans from approximately $1,990/month. Enterprise configurations with advanced features and multiple channels can reach $100,000/year or more. Pricing is configured through a sales conversation based on channel count, tier (Standard vs. Advanced), and AI package selection.

Umbraco licensing and hosting

Umbraco CMS core: Free (MIT license). No per-user fee, no per-channel fee, no seat limit.

Umbraco Cloud 2026 pricing:

• Starter: €45/month
• Standard: €280/month
• Professional: €730/month

Umbraco Heartcore (headless SaaS):

• Starter: €60/month
• Standard: €300/month
• Professional: €1,100/month

Umbraco commercial add-ons (self-hosted, annual license — 2026 figures):

• Umbraco Forms: ~€159/year (single site)
• Umbraco Commerce: ~€800/year (single site)
• Umbraco Workflow: ~€349/year (single site)
• Umbraco Deploy: Included in Umbraco Cloud; separate license for self-hosted teams

These add-on costs are material for SMB deployments and are frequently omitted from Umbraco TCO comparisons. A self-hosted Umbraco site with Forms, Commerce, and Workflow costs approximately €1,300/year in add-on licensing before any hosting or development costs.

Self-hosted Umbraco infrastructure costs (Azure, indicative)

For teams hosting Umbraco on Azure rather than Umbraco Cloud:

These estimates assume a single-region deployment without high-availability configuration. Add ~40–60% for redundancy (secondary App Service Plan, geo-replicated SQL, Application Gateway).

Three-year TCO snapshot

The TCO inflection point: For single-site deployments needing only CMS functionality, Umbraco's cost advantage is durable across 5+ years. For organizations requiring email marketing, personalization, A/B testing, and commerce, the cost of procuring and integrating those tools on Umbraco (both licensing and engineering hours) frequently narrows or eliminates the gap within 2–3 years. For multisite organizations running 5+ properties, Umbraco's flat pricing model creates compounding savings that Kentico's per-channel model cannot match.

How do Kentico and Umbraco compare on G2?

Umbraco holds a 4.5/5 rating from 971 reviews on G2. Kentico holds a 4.4/5 rating from 365 reviews. In G2's comparative research, Umbraco scored higher on ease of use, ease of setup, and ease of administration. Kentico scores higher on built-in feature completeness, marketing capabilities, and vendor support quality — earning a 91% Support rating on G2.

Kentico users report achieving full ROI payback in an average of 19 months; Umbraco users report 15 months. The faster Umbraco payback reflects lower initial licensing cost; the longer Kentico payback reflects higher upfront spend offset by reduced integration overhead over time.

Common G2 criticism patterns:

• Kentico: Pricing opacity, complexity of upgrading between major versions, steep learning curve for new developers
• Umbraco: Requires developer involvement for most configuration changes, lack of native marketing tools, inconsistent third-party package quality

When should you choose Kentico?

Kentico is the better fit when:

• Marketing owns the site autonomously. Your marketing team needs native email, personalization, A/B testing, and campaign management without developer intervention or third-party contracts.
• You want a single vendor relationship. One contract, one support line, one roadmap. No integration matrix to design, maintain, or debug across providers.
• AI-assisted content workflow is a priority. AIRA provides built-in content generation, SEO optimization, and user journey analysis that Umbraco doesn't ship natively. If this capability would otherwise require a separate Jasper.ai or Surfer SEO subscription plus custom integration, the included cost is material.
• You're already on KX13 and the rebuild is acceptable. The upgrade path to Xperience by Kentico is a full rebuild, not an in-place update — your templates, custom modules, and front-end code do not transfer automatically. However, vendor relationships, partner knowledge, and licensing continuity are preserved.
• You're running 1–3 sites. The per-channel licensing model is manageable at low site counts. At higher counts, it becomes a significant cost driver.

When should you choose Umbraco?

Umbraco is the better fit when:

• Budget is a hard constraint. Zero license cost on the core CMS. Self-hosted infrastructure can run under $100/month for low-traffic sites. No per-channel fee regardless of site count.
• You're running a multisite network. Five or more sites under one Umbraco installation carry no additional license cost. The same five sites on Kentico require five channel licenses.
• You need full infrastructure control. You want to choose your hosting provider, CI/CD pipeline, front-end framework, CDN, and marketing tools independently of your CMS vendor.
• You're building headless or hybrid. Umbraco's Content Delivery API and Management API provide REST-based headless delivery without a separate product tier or additional licensing.
• Your engineering team is strong. Umbraco rewards teams that can configure, extend, and maintain the platform. It is a composable foundation, not a turnkey suite — the value scales with developer capability.
• You want open-source auditability. Source code is on GitHub (MIT license). You can fork, modify, and self-host without vendor permission. No lock-in on the core layer.
• You need to integrate specific best-of-breed tools. If you already have HubSpot, Salesforce Marketing Cloud, or Algolia under contract, Umbraco's open API layer integrates with these more cleanly than replacing them with Kentico's built-in equivalents.

A common driver of Kentico-to-Umbraco migrations: organizations find they are paying for Kentico's full suite but actively using only the CMS component, with email handled by HubSpot, analytics by GA4, and search by Algolia — making the premium DXP cost structurally unjustifiable.

What does a Kentico-to-Umbraco migration involve?

There is no native export tool or shared data format between Kentico and Umbraco. The Kentico Migration Tool only supports moves within the Kentico ecosystem (e.g., KX13 to XbyK) — it cannot target Umbraco. Cross-platform migration requires an ETL (Extract, Transform, Load) process built specifically for these two architectures.

Keep two timelines separate: the data migration (moving content records) and the replatform (rebuilding the application). Engineers and vendors routinely conflate these. The data migration is a solved, bounded problem with predictable timelines. The replatform — rebuilding templates, custom modules, and front-end code in Umbraco — is an open-ended development project.

What gets migrated (the data migration)

• Structured content (pages, articles, products, landing pages)
• Media library assets (images, PDFs, documents)
• Taxonomies, categories, tags
• URL slugs and redirect mappings (critical for SEO continuity)
• User data (where applicable and permitted under GDPR/CCPA)
• Multilingual content variants

What doesn't transfer (the replatform — developer scope)

• Page templates and front-end markup (Razor views, CSS, JavaScript)
• Custom .NET modules and business logic
• Marketing automation rules, email templates, campaign configurations
• Kentico Page Builder widget configurations (require transformation and reimplementation)
• Form definitions and submission history (Forms must be recreated in Umbraco Forms)
• Workflow configurations and approval chains

Data extraction from Kentico

Preferred extraction order: API → JSON → CSV. CSV cannot handle nested relational data cleanly and is the least reliable format for complex content models.

Two reliable extraction paths exist for Kentico:

1. Direct SQL extraction. Because Kentico stores custom page types in flat, named tables (CONTENT_Article, CONTENT_Product), you can write SQL scripts joining these tables with CMS_Document and CMS_Tree. A typical extraction query:

SELECT
    t.NodeID,
    t.NodeAliasPath,
    t.NodeLevel,
    d.DocumentCulture,
    d.DocumentName,
    d.DocumentPublishFrom,
    a.ArticleTitle,
    a.ArticleText,
    a.ArticleDate
FROM CMS_Tree t
JOIN CMS_Document d ON t.NodeID = d.DocumentNodeID
JOIN CONTENT_Article a ON d.DocumentForeignKeyValue = a.ArticleID
WHERE t.NodeSiteID = 1
  AND d.DocumentCulture = 'en-US'
ORDER BY t.NodeLevel, t.NodeOrder;

This bypasses the application layer entirely, enabling extraction of hundreds of thousands of records in seconds. For large content volumes (50,000+ items), SQL extraction is 10–100× faster than API extraction.

2. Kentico REST API. For teams that prefer not to touch the database, the REST API outputs structured JSON. This is slower and often requires multiple API calls to resolve linked media assets and taxonomy categories. API rate limits apply and must be handled in the extraction script.

Payload transformation

The most complex engineering challenge is translating data models. Kentico's flat, relational records must be transformed into Umbraco's expected JSON payload format.

Rich text and inline media: Inline images and internal links embedded in rich text fields will break during migration. HTML content stored in Kentico uses /getmedia/{guid}/{filename} URL patterns for media references. These paths do not exist in Umbraco. Your transformation script must:

1. Parse HTML fields using a library (e.g., HtmlAgilityPack in C#)
2. Identify all src and href attributes matching Kentico media URL patterns
3. Download or locate the corresponding media asset
4. Upload it to Umbraco's media library
5. Replace the old Kentico URL with the new Umbraco media path

This cannot be batched or automated generically — the mapping must be built per content type.

Block Grid / Page Builder widget translation: If you are moving Kentico Page Builder widgets, you cannot copy the serialized database string. Kentico and Umbraco use incompatible JSON schemas for component configurations. You must:

1. Parse the Kentico widget property JSON
2. Map each widget type to its Umbraco Block Grid equivalent
3. Reconstruct the content as Umbraco's Block Grid JSON schema

Malformed Block Grid JSON will crash the Umbraco backoffice when an editor opens the migrated page — the error is not graceful. Validate every transformed Block Grid payload against Umbraco's schema before ingestion.

Data ingestion into Umbraco

Never write content data directly to Umbraco's SQL tables. The EAV structure and NuCache layer mean direct SQL writes will create inconsistent state — content may appear in the database but not in the backoffice or on the front end.

Umbraco 13 and earlier: Ingestion requires a custom C# script using the IContentService API:

var contentService = Services.ContentService;
var content = contentService.Create("Article Title", parentId, "article");
content.SetValue("articleTitle", "My Title");
content.SetValue("articleBody", "<p>Body content here</p>");
content.SetValue("articleDate", DateTime.UtcNow);
contentService.SaveAndPublish(content);

IContentService handles database writes, updates the XML cache, triggers events, and ensures the backoffice reflects new content correctly.

Umbraco 14+ (including v17): The platform introduced the Management API — a fully functional REST API for backoffice operations. You can POST JSON payloads directly to Umbraco endpoints from any external script, language, or runtime:

POST /umbraco/management/api/v1/document
Authorization: Bearer {token}
Content-Type: application/json
 
{
  "contentTypeKey": "article-content-type-guid",
  "parentId": "parent-node-guid",
  "values": [
    { "alias": "articleTitle", "value": "My Title", "culture": "en-US" },
    { "alias": "articleBody", "value": "<p>Body content</p>", "culture": "en-US" }
  ]
}

The Management API simplifies ingestion for headless or decoupled migration workflows and removes the dependency on running code inside the Umbraco application context.

How long does the data migration take?

The data migration — extracting content from Kentico and loading it into Umbraco — typically completes within 1–5 business days for standard datasets. Small datasets under 10,000 records can finish in under 24 hours.

What determines timeline variance:

• Number of distinct content types (each requires its own field mapping)
• Presence of Block Grid / Page Builder components (highest complexity)
• Media volume and whether media files require downloading and re-uploading
• Multilingual variants (each culture is a separate content record)
• API rate limits if using API extraction rather than SQL
• Availability of a staging Umbraco environment for validation

These timelines describe the data migration only. They do not include the replatform — rebuilding templates, front-end code, custom modules, and third-party integrations in Umbraco. The replatform is a separate development project that your team owns. Begin scoping at least 3–4 months before any hard deadline, and treat the data migration and the replatform as independent work streams with independent schedules.

The December 2026 end-of-support overlap

Both ecosystems face end-of-support deadlines within weeks of each other:

• Kentico Xperience 13: End of support December 31, 2026
• Umbraco 13: End of life December 14, 2026

Teams on either platform need a migration or upgrade plan in motion now. Both transitions are significant:

Kentico KX13 → Xperience by Kentico: This is a full application rebuild. Kentico's official Migration Toolkit handles structured content, media, and some configuration — but does not migrate Page Builder widget configurations, custom modules, email templates, or marketing automation rules. The front-end application must be rebuilt from scratch in Xperience by Kentico's architecture. Typical timeline for a mid-complexity site: 4–9 months including discovery, development, and UAT.

Umbraco 13 → Umbraco 17: The jump involves migrating to a new backoffice built on Lit/web components (introduced in v14). Custom packages, dashboard extensions, and backoffice customizations built against the AngularJS-based v13 backoffice must be rewritten. Content data migrates cleanly via Umbraco's upgrade path, but the application layer requires meaningful developer work. Typical timeline: 1–4 months depending on custom package complexity.

Making the decision

The Kentico-vs-Umbraco decision maps cleanly to two organizational profiles:

Choose Kentico when: Your marketing team actively self-serves native personalization, email automation, and A/B testing without developer support. You prefer a single vendor contract over a managed integration matrix. You're running 1–3 sites where per-channel pricing is manageable. You have budget for a premium DXP and want AI-assisted content workflows included.

Choose Umbraco when: Budget is a hard constraint and zero core licensing cost is structurally necessary. You're running 5+ sites where per-channel fees compound. Your team already has best-of-breed marketing tools under contract (HubSpot, Salesforce, etc.) that would be replaced, not supplemented, by Kentico's built-ins. Your engineering team has capacity to build and maintain integrations. You need infrastructure flexibility across hosting providers.

The 2026 end-of-support deadlines make this evaluation time-constrained. The data migration between platforms is a bounded, solvable problem. The replatform is where your time, developer capacity, and budget will be concentrated — and it requires a longer runway than most teams allocate.

For teams evaluating alternatives beyond these two platforms, see our analysis of Kentico alternatives and Umbraco alternatives for headless-native options including Contentful, Sanity, and Storyblok.