Sitefinity vs ExpressionEngine: Architecture, TCO & Migration

Sitefinity vs ExpressionEngine: Architecture, TCO & Migration

Sitefinity is a proprietary .NET CMS by Progress Software with enterprise licensing, built-in personalization, and managed cloud hosting on Azure. ExpressionEngine is an open-source PHP/MySQL CMS with channel-based content modeling and low licensing overhead. They share the label "CMS" but target different organizations, run on fundamentally different tech stacks, and impose very different cost structures.

If you are comparing them, you are choosing between an enterprise digital experience platform (DXP) with vendor-managed infrastructure and formal governance tooling, and a developer-controlled, self-hosted content framework that assumes nothing about your data.

One-line verdict: Choose Sitefinity if you need .NET ecosystem integration, built-in personalization and analytics, managed cloud hosting, and your organization can absorb $15,000+/year in licensing. Choose ExpressionEngine if you want full code ownership, low license costs, flexible content modeling via channels, and you have PHP developers who can manage infrastructure.

What Is Sitefinity?

Sitefinity is a commercial web content management system built on ASP.NET, published by Progress Software (formerly Telerik). By default, Sitefinity CMS uses relational SQL DB storage, with the database layer implemented through the Telerik DataAccess ORM delivering support for Microsoft SQL Server and Azure SQL.

Sitefinity's multi-layer architecture is built around extensibility, interoperability, and flexibility, achieved through abstraction patterns and a public API for all system components.

The platform ships in three deployment models:

• Sitefinity DX (self-hosted): You manage the infrastructure. Best for IT-driven teams with specific architecture requirements.
• Sitefinity Enterprise (self-hosted): Unlimited users, 24/7 support, advanced personalization via Sitefinity Insight.
• Sitefinity Cloud: Built on a containerized architecture using Azure Kubernetes Service (AKS), with Cloudflare WAF, DDoS Protection, and SSL/TLS included. Runs across three independent availability zones within the same region, providing high availability and fault tolerance without manual intervention on zone failure.

The CMS core requires Windows, IIS, .NET Framework 4.8, and SQL Server or Azure SQL. Progress also supports a decoupled install path where the frontend runs as a standalone ASP.NET Core or Next.js renderer. Sitefinity exposes content via both an OData REST API and GraphQL, with authentication, CORS, and field-level restrictions applied consistently across both.

Modules are highly decoupled entities that can be installed or uninstantiated separately, each packaging their own UI, data storage, public API, REST API, configuration, and workflow. Most capabilities — News, Blogs, Libraries, Forms, Translations — are wrapped as modules. The platform includes native digital asset management, multi-site management, A/B testing, and personalization engines (Sitefinity Insight) that would require third-party tools in most other CMS ecosystems.

Sitefinity Insight is a separate data processing product — not simply a checkbox feature on the base CMS. It has its own data collection pipeline, visitor profile store, and segment engine, and operates under its own GDPR data processing surface area. Buyers comparing "built-in personalization" should understand that Insight involves a second system with its own pricing tier and its own EU data residency considerations.

Upgrade complexity note: Organizations running Sitefinity 10–12 face non-trivial upgrade paths to Sitefinity 14+. The widget framework changed substantially (from MVC widgets to ASP.NET Core renderers), meaning custom widgets typically require rewriting rather than porting. This is a real migration trigger — teams choosing to upgrade the CMS often find it cheaper to migrate platforms entirely.

What Is ExpressionEngine?

ExpressionEngine (EE) is an open-source CMS built on PHP and MySQL, originally launched in 2004. It is maintained by Packet Tide and licensed under the Apache License, Version 2.0.

Unlike WordPress, which makes assumptions about your content, ExpressionEngine assumes nothing. It provides an empty canvas and a set of powerful tools — Channels, Templates, Members — to build exactly the data structure you need.

EE's core concept is the Channel: a flexible data container where you define custom fields (text, date, file, relationship, grid) to model any content type. Templates use EE's proprietary tag syntax ({exp:channel:entries}) to pull and display data. The tag syntax is parsed by the engine and is readable by frontend developers who do not know PHP. You fetch entries with parameters for channel, category, limit, sorting, relationships, and IDs.

System requirements for EE 7: PHP 8.3 is fully supported, with a minimum of PHP 7.2.5+ with 32M of memory, and MySQL 5.6.4+. MariaDB is a drop-in replacement for MySQL and often appears more performant, though there are edge cases where the opposite is true.

ExpressionEngine follows a monolithic architecture (PHP rendering HTML server-side) but has modernized in version 7+ to support hybrid and headless implementations. First-party headless guidance mostly shows templates that emit JSON — workable for smaller endpoints and AJAX use cases, but not equivalent to Sitefinity's OData/GraphQL delivery model.

Security track record: Several CVEs exist in older EE versions, primarily related to CSRF handling and file upload validation in the EE 2.x and 3.x era. EE 6+ and EE 7 have a cleaner record, but compliance-conscious buyers running legacy installs should audit open CVEs before deciding whether to migrate or upgrade in place. The NIST NVD lists historical EE vulnerabilities under CPE cpe:/a:ellislab:expressionengine.

One operational catch worth knowing: if you use ExpressionEngine's dynamic_parameters to drive filterable template output, page caching must be off for that template. That is a real trade-off if you are trying to turn template endpoints into pseudo-APIs under load.

How Does the Architecture Compare?

This is where the decision often gets made — or should get made — before pricing enters the conversation.

Where Each Architecture Breaks Down

Sitefinity ties you to the Microsoft ecosystem. If your team runs Linux infrastructure, uses PostgreSQL, or works primarily in Python/Node.js, you are fighting the platform. The community and available resources are smaller compared to more widely used CMS platforms like WordPress or Drupal. Finding solutions or troubleshooting obscure issues requires more effort, and Progress's own forums are the primary community resource.

ExpressionEngine has a shrinking ecosystem. EE has passed through several hands — Ellis Lab to EllisLab Inc. to Packet Tide — without sustained investment in the core product until Packet Tide's stewardship. The add-on marketplace is thin compared to WordPress or Craft CMS. Complex personalization, A/B testing, or enterprise analytics require significant custom development. EE developers are harder to find and do not come cheap. ExpressionEngine is a highly specialized CMS, and some organizations find development and management cost-prohibitive precisely because the talent pool is concentrated among agencies that adopted EE in the 2008–2015 window.

Total Cost of Ownership

TCO is where these platforms diverge most dramatically. Sitefinity is enterprise-priced. ExpressionEngine is indie-priced. But sticker price alone misleads — you either pay upfront for licensing and support, or you pay continuously for engineering time and maintenance.

Sitefinity Pricing

Progress does not publish fixed prices — licensing is quote-based and depends on scope.

• Sitefinity DX includes 1 Production Domain or Server, Unlimited Content Types, 10 Concurrent Users, and 24/5 Customer Support.
• A single Enterprise License for a single domain (with no sub-domains) costs approximately $15,000, based on documented third-party procurement experiences and reseller quotes. Progress Software does not publish a public rate card; treat this as a directional floor, not a negotiated ceiling.
• The Enterprise package includes unlimited users. Both options include 1 production domain or server; additional domains or servers require a purchased add-on.
• Non-production domains (dev, testing, staging subdomains) do not require additional licenses.

What Sitefinity Insight costs separately: Insight is licensed on top of the base CMS and priced by visitor volumes and data retention requirements. Buyers who plan to use personalization must request a separate Insight quote. Bundled pricing exists but is not automatic.

Hidden costs: .NET developer rates are generally higher than PHP. Microsoft SQL Server licensing if self-hosted (Standard Edition starts at ~$900/core; Enterprise is significantly higher). Windows Server licensing if self-hosted. Azure infrastructure costs if using Sitefinity Cloud (AKS node pools, storage, bandwidth — not included in the CMS license price). One-time fees for implementation, project discovery, website design, development, migration costs from legacy systems, training costs, and add-ons for additional domains or servers.

Concurrent user cap risk: The DX tier caps at 10 concurrent backend users. For organizations with more than 10 editors publishing simultaneously, this is not a minor limitation — it is a hard ceiling that forces an upgrade to Enterprise. The cost differential is substantial and rarely mentioned in vendor collateral.

ExpressionEngine Pricing

• ExpressionEngine 7 Core is free under Apache 2.0.
• Pro opens up unlimited control panel users and is initially $249 for the first year of updates. After the first year, a Pro license can be renewed for as low as $49/yr.
• Each additional MSM site license is $49 for the first year of updates, and can then be renewed for as low as $39/year.

What happens when a Pro license lapses: If you do not renew, the software continues to function. You lose access to updates, security patches, and official support. An organization with 50 control panel users running on an unpatched EE install is taking on real operational risk — this is a common scenario for EE sites that outlive the agency that built them.

Hidden costs: Self-managed hosting (shared hosting from ~$4/mo to dedicated servers at $100–$500/mo). Third-party add-ons for features Sitefinity includes natively (personalization, analytics, advanced search). Security patching and server maintenance is 100% your responsibility. Developer talent pool is small and concentrated among agencies that adopted EE years ago.

3-Year TCO Estimate

Developer hourly rates are based on U.S. market ranges from Stack Overflow Developer Survey data and agency rate cards; actual rates vary by geography and specialization. Hosting ranges reflect typical configurations, not edge cases.

Content Modeling: Channels vs Dynamic Modules

ExpressionEngine's Channel Model

EE's content architecture revolves around Channels. A Channel is a container for entries — "Articles," "Staff Directory," "Events" — and you assign custom fields to it.

Data modeling is done via the Control Panel. You create a Field Group, add fields (e.g., "Event Date", "Location Map"), and assign it to a Channel. This separates the "Content Architect" role from the "Template Developer" role effectively.

EE database schema for content: Channel entry metadata is stored in exp_channel_titles with columns including entry_id (INT, primary key), channel_id, author_id, title, url_title, status, entry_date, expiration_date, and site_id. Custom field values in modern EE versions are stored in channel-specific tables named exp_channel_data_field_X (one table per field), which improves query performance on large datasets but complicates bulk extraction queries that must JOIN across many field tables.

Key extraction tables:

• exp_channel_titles — title, URL title, status, dates, author
• exp_channel_data (legacy) or exp_channel_data_field_N (modern, per-field tables) — custom field values
• exp_categories and exp_category_posts — taxonomy assignments
• exp_members — user accounts and member data
• exp_upload_prefs — file upload directory configuration

EE also features Fluid Fields, which act as a flexible content matrix, allowing authors to mix text, images, and relationships in a dynamic order. Fluid Field values are stored in exp_fluid_field_data, with each block serialized as a row referencing the parent entry_id, a field_id, and an order. The actual block content is stored in a secondary table per Fluid Field (exp_fluid_field_data_field_X). This nested, ordered structure means you cannot extract Fluid Field content with a single JOIN — you must query exp_fluid_field_data for block order, then query each block-type table separately to reconstruct the full field value.

Channels are flexible but flat by default. Relationships between channels require explicit Relationship fields. There is no built-in hierarchy like Sitefinity's page tree. For sites with deep content hierarchies — government portals, university sites — this requires workarounds with categories, relationships, or separate channels.

Sitefinity's Module-Based Model

Sitefinity uses a Module Builder to create custom data structures. When you create a new dynamic module (e.g., "Press Releases" or "Product Catalog"), Sitefinity automatically generates the underlying SQL Server tables, the backend CRUD interface, and the API endpoints.

Sitefinity database schema for content: Sitefinity uses a GUID-based content versioning model. A dynamic module named "PressRelease" generates at minimum three SQL Server tables: sf_press_release (master record, contains the authoritative GUID), sf_press_release_live (published snapshot), and sf_press_release_draft (current draft). The content_id column is a GUID (uniqueidentifier in SQL Server). Related data — taxonomies, permissions, workflow state — is stored in shared system tables keyed to this GUID. A direct SQL query against only the master table will return all versions; filtering for visible = 1 on the live table is the correct pattern for extracting published content only.

Dynamic modules can be hierarchical and tie into Sitefinity's lifecycle system, which tracks master, temp, live, and deleted states. Content types automatically get REST API endpoints, widget templates, workflow support, and search indexing — things you build manually in EE.

The platform supports one-, two-, and three-level approval workflows out of the box. Permissions are inheritable, and explicit deny overrides are available. These details reduce the amount of custom governance code you need to write around publishing.

API pagination: Sitefinity's OData REST API uses $skip and $top query parameters. The default page size is 50 items. For bulk extraction, set $top=100 (the documented maximum for most endpoints) and iterate using $skip. Some media library endpoints have lower effective limits under load. Plan for retry logic with exponential backoff when extracting large datasets.

Multisite, Multilingual, and Search

These three capabilities create some of the starkest differences in operational overhead.

Sitefinity supports page translations out of the box and serves the version matching the current language automatically. In a multisite instance, some modules are shared across all sites (Users, Roles, Permissions, Classifications, Email Campaigns), and you can share forms, page templates, widget templates, and module content across sites. Pages themselves cannot be shared live — only duplicated or copied. For brand portfolios and regional rollouts, plan around this limitation.

ExpressionEngine's Multiple Site Manager lets you run multiple sites from one installation, with separate templates, channels, and preferences per site. You can pull content across sites with the site="" parameter. But all sites must live on the same server, and language packs do not automatically translate site content. Multilingual delivery becomes a site-architecture problem rather than a built-in workflow.

For search, Sitefinity ships with Lucene by default and can switch to Azure AI Search or Elasticsearch. ExpressionEngine's native search is basic — it queries exp_channel_titles and exp_channel_data with LIKE operators, which degrades at scale. The Pro Search add-on adds a full-text index, relevance weighting, advanced filters, keyword suggestions, and cross-site search. If search quality affects conversion or support deflection, price this add-on explicitly rather than treating it as a side feature.

Performance at scale: Sitefinity with Lucene handles tens of thousands of content items without significant configuration. EE's native search degrades noticeably above ~10,000 entries on shared hosting due to full-table scans. Neither platform publishes official load benchmarks, but this reflects documented community experience across EE developer forums and Sitefinity support cases.

Data Export and Migration Paths

This is where both platforms have real limitations — and where most comparison articles go soft.

Getting Data Out of Sitefinity

Sitefinity CMS enables you to export and import website content and data structure, with full support for the Content Management Interoperability Services (CMIS) open standard.

Export options:

• REST API (OData): The Sitefinity CMS Content API provides RESTful access to all content types. Developers use it to create, read, update, and delete content items. This is the best path for programmatic extraction to a non-Sitefinity target. Filter for published content using $filter=Visible eq true or Status eq 'Live' depending on the endpoint. Use $top=100&$skip=N for pagination.
• Site export: ZIP-based export of structure and content, designed for Sitefinity-to-Sitefinity transfers.
• Deployment export: Exports dynamic module structure, configurations, taxonomies, custom fields of static modules, and widget templates.
• Direct DB access: If self-hosted, you can query SQL Server directly against the live tables (e.g., sf_[module_name]_live WHERE visible = 1). On Sitefinity Cloud, you will need to manually request a data export from Progress Support.

Getting Data Out of ExpressionEngine

EE stores everything in MySQL, which means you have direct database access on any self-hosted instance. A reliable bulk extraction query for channel entries looks like this:

SELECT
  ct.entry_id,
  ct.title,
  ct.url_title,
  ct.status,
  ct.entry_date,
  ct.site_id,
  cd.field_id_1 AS body_text,
  cd.field_id_4 AS summary
FROM exp_channel_titles ct
LEFT JOIN exp_channel_data cd ON ct.entry_id = cd.entry_id
WHERE ct.channel_id = 3
  AND ct.status = 'open'
ORDER BY ct.entry_date DESC;

Replace field_id_1, field_id_4, and channel_id = 3 with values from your exp_channel_fields and exp_channels tables respectively. In modern EE versions, field data may be in exp_channel_data_field_1, exp_channel_data_field_4 (separate tables per field) rather than columns on exp_channel_data — check your EE version before writing extraction queries.

Extraction options:

• Direct MySQL queries — most reliable for bulk export; fastest for large datasets
• EE's template engine — render content as JSON/XML via custom templates; slow for large entry counts
• REST API (EE 7) — newer and less documented; use ?limit=100&page=N parameters; no published rate limits
• mysqldump — full database backup for migration staging; safest starting point before any destructive operations

One gotcha: upgraded ExpressionEngine sites may still contain old {filedir_X} patterns or run in File Manager Compatibility Mode, which disables newer file features until references are converted. Run this query to identify affected content before migration:

SELECT entry_id, field_id_1
FROM exp_channel_data
WHERE field_id_1 LIKE '%{filedir_%';

Normalize all {filedir_X} references to absolute paths before migration or you will leak broken inline media into the target system.

Sitefinity → ExpressionEngine Migration

Organizations typically make this move to eliminate high licensing costs, transition away from the Microsoft stack, or gain more direct control over frontend markup.

1. Authenticate via OAuth2 and extract content through Sitefinity's OData REST API, filtering for published content only ($filter=Visible eq true). Paginate with $top=100&$skip=N. Log every API response — retry logic is essential as Sitefinity's media endpoints can time out under sustained load.
2. Map Sitefinity Dynamic Modules to EE Channels. Map Sitefinity Tags and Categories to EE Categories.
3. Handle relational data carefully: import parent records first, capture new EE entry_id values, then use those IDs when importing child records with Relationship fields. The import order matters because EE Relationship fields store entry_id foreign keys, not slugs.
4. Download all media assets from Sitefinity Libraries, upload to EE Upload Directories, and run regex replacement across all HTML content to swap Sitefinity GUID URLs (/docs/default-source/my-image.jpg?sfvrsn=123) with new EE file paths.
5. Rebuild all templates in EE's tag syntax — there is zero template portability between .NET and PHP.
6. Recreate URL structure and configure 301 redirects.

ExpressionEngine → Sitefinity Migration

Organizations make this move when they need strict compliance, native personalization, headless architecture with official API support, and enterprise SLA.

1. Export content from MySQL directly. Core tables are exp_channel_titles and the field-specific data tables. Direct SQL is preferred over APIs for large datasets, especially for complex field types like Fluid Fields or Grid that require custom queries to flatten (see the Fluid Field section below).
2. Map EE Channels and Field Groups to Sitefinity Dynamic Modules.
3. Import via a custom C# console application using the Sitefinity Native API — the most reliable method for bulk ingestion. The API lets you programmatically create items, set workflow status to Live, and generate the necessary GUIDs. Using the API (rather than direct SQL inserts) ensures Sitefinity's versioning tables (_master, _live, _draft) are all populated correctly.
4. Migrate media files to Sitefinity Libraries and rewrite all inline references.
5. Rebuild templates in ASP.NET Core / Razor. There is no partial portability — EE tag syntax and .NET Razor are incompatible by design.
6. Recreate taxonomy (EE categories → Sitefinity classifications), map users and roles, and configure 301 redirects.

The Fluid Field Problem

If your EE build relies heavily on Fluid Fields or Grid fields, mapping to Sitefinity requires architectural decisions up front. Sitefinity's closest equivalent is the Page Builder with custom widgets, or child Dynamic Modules. You cannot map a dynamic, multi-block EE Fluid Field directly into a standard Sitefinity rich text field without losing structural integrity.

The extraction process for Fluid Fields requires three queries per entry:

-- Step 1: Get block order for a given entry
SELECT id, field_id, order, fluid_field_data_id
FROM exp_fluid_field_data
WHERE entry_id = 1234
ORDER BY order ASC;
 
-- Step 2: For each block type, query the corresponding block table
-- Example for a text block (field_id = 7)
SELECT content
FROM exp_fluid_field_data_field_7
WHERE fluid_field_data_id = 99;

You must loop through each block row from Step 1, determine its field type, and fetch content from the corresponding exp_fluid_field_data_field_X table. The practical approach for migration is to reconstruct the ordered block sequence as a JSON array during extraction, then programmatically assemble it into Sitefinity Content Blocks or decoupled JSON payloads for a headless frontend.

Migration Tips That Save Real Time

Automated tools like CMS2CMS currently do not support migration from ExpressionEngine to Sitefinity or vice versa. This is a custom migration in every case.

A source-of-truth mapping file for every record and asset helps de-risk the build:

{
  "source_system": "sitefinity",
  "source_id": "news:12345",
  "target_type": "press_release",
  "locale": "en-US",
  "slug": "q2-results",
  "asset_keys": ["hero-7781", "pdf-9912"],
  "status": "live"
}

On the 80/20 effort split: In migrations between platforms with incompatible template engines — which every Sitefinity ↔ ExpressionEngine migration is — the content data transfer is rarely the bottleneck. Template rebuilds, URL mapping, widget/module reconstruction, and edge-case validation typically consume more calendar time than the data pipeline. The exact ratio depends on content volume, template complexity, and how many custom modules exist. A site with 2,000 entries and 40 custom page templates will spend far more time on templates than data. A site with 200,000 entries and 5 simple templates will invert that ratio.

What happens during Sitefinity Cloud zone failure: Sitefinity Cloud on AKS is configured across three availability zones. In a zone failure, Kubernetes reschedules pods to surviving zones automatically. In-flight write requests that were mid-transaction at failure time may not complete — Sitefinity's ORM does not guarantee write completion during zone-level failover. If you are running migration imports against a Sitefinity Cloud instance, use idempotent write operations keyed on SystemSourceKey so re-runs do not create duplicate records.

When to Choose Sitefinity

• Your engineering team is built around C# and ASP.NET.
• You need formal approval workflows with one to three approval levels out of the box.
• Your marketing team needs native personalization (Sitefinity Insight), A/B testing, and analytics without third-party tools — and you have budget for Insight's separate licensing.
• You need built-in multilingual page management and multisite content sharing.
• Compliance requires managed infrastructure — Sitefinity Cloud is designed for digital teams in regulated industries needing faster delivery and less IT dependency.
• Your backend editor count will stay under 10 concurrent users (DX tier) or you are buying Enterprise.
• Your annual CMS budget is $50K+ and enterprise procurement cycles are normal.

When to Choose ExpressionEngine

• Your engineering team prefers PHP and open-source stacks.
• You want absolute control over your database schema and HTML output.
• You need maximum content modeling flexibility at minimum licensing cost — EE Core is free, and Pro is $249 for the first year.
• You want full code ownership under Apache 2.0 with no vendor lock-in on the application layer.
• Your budget is under $5,000/year all-in. There is no version of Sitefinity that fits this budget.
• Your site is content-heavy but feature-light: you do not need personalization, A/B testing, or enterprise analytics.
• You have an internal PHP team or a trusted EE agency and do not rely on a broad developer marketplace.

Risks and Honest Trade-Offs

Sitefinity risks:

• Vendor lock-in to Progress Software and the Microsoft stack — data extraction requires either REST API access or SQL Server credentials
• Pricing opacity — no public rate card means potential surprise renewals; Insight pricing is completely separate from base CMS pricing
• The 10 concurrent user cap on DX tier is a hard operational limit that forces Enterprise upgrades
• Smaller community than WordPress, Drupal, or Craft CMS; specialized troubleshooting often requires Progress support tickets rather than community forums
• Upgrade complexity between major version tiers requires custom widget rewrites, not just package updates

ExpressionEngine risks:

• EE has passed through several ownership transitions, raising long-term continuity questions for organizations with 5–10+ year planning horizons
• Shrinking add-on ecosystem; many plugins built for EE 2.x and 3.x are unmaintained and incompatible with EE 7
• No managed hosting option from the vendor — all operational risk, including security patching, is yours
• Developer talent pool is concentrated among agencies that adopted EE in the 2008–2015 window; new EE expertise is not being developed at scale
• EE v7 REST API and headless capabilities are newer and less battle-tested than Sitefinity's at enterprise data volumes
• Lapsed Pro licenses leave sites running on unpatched software — a common scenario for EE sites that outlive their original agency

Competitive Context: Where Craft CMS Fits

The most common alternative to both Sitefinity and ExpressionEngine is Craft CMS, which shares EE's PHP/MySQL foundation and channel-inspired content modeling but offers a significantly larger and more active plugin ecosystem, a modern GraphQL API, and a developer experience that has attracted much of the talent that left EE after its ownership transitions. Craft's pricing ($299/year for Pro, $999/year for Enterprise) sits between EE Pro and Sitefinity, and its headless capabilities are more mature than EE v7's REST API. If you are evaluating ExpressionEngine and are not committed to EE specifically, Craft CMS should be on the same shortlist.

Making the Decision

Answer these five questions:

1. What tech stack does your team already run? .NET → Sitefinity. PHP → ExpressionEngine (or Craft CMS).
2. What is your annual CMS budget? Under $5K → EE is your only option. $5K–$50K → EE Pro plus custom development, or Craft CMS. Over $50K → Sitefinity becomes viable.
3. Do you need built-in personalization with formal vendor support? Yes → Sitefinity (budget for Insight separately). No → either works.
4. Do you have the ops team to manage your own hosting and security patching? No → Sitefinity Cloud. Yes → either works.
5. How important is vendor independence and code ownership? High → EE or Craft (Apache 2.0, self-hosted). Low → Sitefinity is fine.

If you are migrating between these platforms, the hardest part is not the data — it is mapping content structures across fundamentally different architectures and rebuilding the presentation layer from scratch. Design the content model and ID strategy first, write the extraction queries against your actual database schema, then move the data. That single sequencing decision prevents most downstream rework. If you want to understand when outsourcing migration work makes sense, we have written about that separately.