Liferay DXP 7.4: Open-Source Pricing, Architecture & Deployment Guide

Executive Summary

Liferay DXP 7.4 (GA released February 2024) represents the maturation of Liferay's transition from a traditional JSR-286 portlet portal to a modern, modular digital experience platform. Unlike Adobe Experience Manager or Sitecore, Liferay's architecture is built on OSGi (Open Service Gateway Initiative) — a dynamic module system for Java that enables true runtime modularity, hot deployment, and version isolation without container restarts.

The platform ships in three editions: Community Edition (CE) — free, open-source (LGPL 2.1), no SLA; Digital Experience Platform (DXP) — commercial license with Liferay Cloud (SaaS), 24/7 support, hotfixes, and enterprise modules (Analytics Cloud, Commerce, Audience Targeting); and DXP Cloud — fully managed PaaS with automated CI/CD, scaling, and compliance certifications (SOC2, ISO27001, HIPAA-ready).

Critical differentiator: Liferay DXP is the only major DXP where you own the source code. This eliminates vendor lock-in at the platform layer — you can self-host indefinitely, fork the codebase, or migrate to any infrastructure provider. The trade-off: your team owns the operational burden (patching, scaling, security hardening) unless you purchase Liferay Cloud. See our Liferay vs Acquia comparison for a side-by-side look at how Liferay stacks up against the other major open-source DXP.

Modular Architecture: OSGi, Modules & Extension Points

OSGi Runtime & Module Layer

Liferay DXP 7.4 runs on Apache Felix 7 (OSGi R7 compliant) atop a servlet container (Tomcat 10.1 for Servlet 6.0 / Jakarta EE 10). Every capability — CMS, Forms, Commerce, Search, User Management — ships as an OSGi bundle (JAR with MANIFEST.MF metadata declaring exported/imported packages, version ranges, and service declarations). This architecture delivers:

• Runtime hot deployment: Install, update, or uninstall modules without server restart. Bundles transition through INSTALLED → RESOLVED → STARTING → ACTIVE states managed by the Felix framework.
• Version isolation: Multiple versions of the same library (e.g., Jackson 2.13 and 2.15) coexist via package version constraints in Import-Package headers. No "dependency hell" across modules.
• Service registry: Components publish OSGi services (via Declarative Services annotations @Component, @Reference) consumed by other bundles. This replaces Spring's application context for cross-module communication.
• Fragment bundles: Extend core modules (e.g., override JSPs, Language.properties, CSS) without touching source — critical for upgrade-safe customization.

Headless Architecture: GraphQL, REST & Content Delivery

Liferay's headless delivery is built on three API layers, each serving different consumption patterns:

1. Headless REST API (v1.0 — stable since 7.3)

Resource-oriented endpoints following JSON:API spec. Key resources: /v1.0/sites/{siteId}/content-structures, /v1.0/sites/{siteId}/content, /v1.0/sites/{siteId}/pages. Supports pagination, filtering (RSQL syntax), field selection (?fields=id,title,content), and optimistic locking via ETags. Authentication: OAuth2 (Client Credentials, Authorization Code), JWT Bearer, or Basic Auth for server-to-server.

2. Headless GraphQL API (v1.0 — GA in 7.4)

Single endpoint /o/graphql with introspection enabled. Schema auto-generated from content structures (Dynamic Data Mapping). Supports fragments, variables, directives (@skip, @include), and persisted queries. Critical limitation: no real-time subscriptions — for live updates, poll or use Server-Sent Events via custom endpoint. Query complexity limited to depth 10, 1000 nodes max to prevent DoS.

3. Content Delivery Network (CDN) Integration

Liferay Cloud includes Fastly CDN with automatic cache invalidation via surrogate keys. On-premises deployments require manual Varnish/Fastly/Cloudflare configuration. Cache tags: site:{siteId}, content:{contentId}, structure:{structureId}. Stale-while-revalidate default: 60s. For high-traffic public sites, implement edge-side includes (ESI) for personalized fragments.

Search Architecture: Elasticsearch 8.x Integration

Liferay 7.4 bundles Elasticsearch 8.11 (embedded) or connects to remote cluster (recommended for production). Index structure: one index per virtual instance (liferay-20099 for companyId=20099). Document types deprecated — single _doc type with entryClassName field for filtering.

• Indexer framework: Background indexing via IndexerPostProcessor chain. Custom indexers implement BaseIndexer for non-Liferay entities.
• Query DSL: Liferay's SearchContext wraps Elasticsearch bool queries. Supports nested queries for DDRepeatable fields, geo-distance for asset locations, and learning-to-rank via FunctionScoreQuery.
• Synonyms & Analyzers: Configure per-language analyzers in portal-search-elasticsearch8 module. Korean (Nori), Japanese (Kuromoji), Chinese (SmartCN) require separate plugin installation.

Database & Persistence Layer

Service Builder generates Hibernate mappings from service.xml. Liferay 7.4 supports: MySQL 8.0 (InnoDB, utf8mb4), PostgreSQL 15+, Oracle 19c/21c, SQL Server 2019/2022, MariaDB 10.6+. Critical: no MariaDB Galera Cluster support for Liferay's distributed caching — use single-writer with read replicas only. Connection pooling via HikariCP 5.x (default 20 connections per node).

Deployment Models: Operational Reality Check

Option 1: Liferay Cloud (SaaS/PaaS) — Recommended for 80% of Enterprises

Option 2: Self-Managed Kubernetes (On-Prem / Private Cloud)

Deploy via Liferay Helm Charts (v3.0+). Requires: Kubernetes 1.28+, cert-manager, NGINX Ingress, ExternalDNS, Prometheus/Grafana stack, Elasticsearch Operator (ECK), PostgreSQL Operator (CloudNativePG). Team needs: 2+ DevOps engineers, 1 Liferay platform specialist. Typical cluster: 3 master nodes (m6i.xlarge), 6 worker nodes (m6i.2xlarge, 32GB/8CPU), 2TB gp3 EBS per node. Annual infra cost: ~$180K-$250K (AWS) excluding licenses.

Option 3: Traditional VM / Bare Metal (Legacy On-Prem)

Still supported but not recommended for new implementations. Tomcat clustering via RedisSessionManager (Liferay module) for session replication. Database: Oracle RAC or PostgreSQL with Patroni. Search: Elasticsearch cluster (3 master + 4 data nodes). Load balancer: F5/HAProxy with sticky sessions. Patching cycle: quarterly Liferay fix packs + monthly OS patches. Requires 24/7 NOC for production.

Docker Compose (Development Only)

liferay/dxp:7.4.13-ga14 image (~2.1GB). Includes Tomcat, Elasticsearch, PostgreSQL in single container. Do not use in production — no HA, no backup, no upgrade path.

Migration Pathways: 6.2 → 7.4, 7.x → 7.4, Portal → DXP

Liferay 6.2 (EOL 2020) → 7.4: The "Big Bang" Migration

This is a complete rewrite, not an upgrade. 6.2 used Portlet 2.0 (JSR-286), Spring MVC, JSP, Service Builder v1. 7.4 uses OSGi, Declarative Services, React/Metal.js frontend, Service Builder v2, Gradle workspace. No automated migration tool exists for custom code.

Recommended approach: Greenfield 7.4 implementation with content migration only. Use LAR (Liferay Archive) export/import for web content, documents, users, organizations. Custom portlets → rewrite as OSGi modules (MVC Portlet, JAX-RS, or React widgets). Theme → migrate to Theme Builder (npm-based) or rewrite as FreeMarker/Velocity templates. Budget: 12-18 months for mid-size portal (50+ custom portlets).

Liferay 7.0/7.1/7.2/7.3 → 7.4: In-Place Upgrade

Supported upgrade path per Liferay's official documentation. Key steps:

1. Upgrade database schema via upgrade:execute Gradle task (runs all upgrade processes sequentially — can take 4-12 hours for 500GB DB).
2. Migrate modules: Update bnd.bnd version ranges, replace deprecated APIs (e.g., PortalClassLoaderUtil → ModuleClassLoader).
3. Theme migration: 7.0-7.2 themes (Gulp) → 7.3+ (npm + liferay-theme-tasks). Run npx liferay-theme:upgrade.
4. Search reindex: Full reindex required post-upgrade (Elasticsearch 7→8 mapping changes). Schedule 24-48 hours downtime or use blue-green.

Breaking changes in 7.4: JDK 11→21, Tomcat 9→10 (javax→jakarta namespace), Elasticsearch 7→8, Removal of portal-service.jar (use OSGi services), AssetRendererFactory refactored.

Portal-to-Headless Decoupling (Strangler Fig Pattern)

For organizations moving from server-side rendering to headless:

1. Keep Liferay as content repository + auth + permissions.
2. Build new frontend (Next.js, React, Vue) consuming Headless GraphQL/REST.
3. Use Liferay Fragments for gradual migration — embed React apps inside Liferay pages via fragment-entry.
4. Implement SSO via OAuth2/OIDC (Liferay as IdP or SP) for seamless auth across old/new.
5. Decommission server-side rendering page by page.

Liferay Pricing

Liferay pricing spans three editions, making it one of the most flexible DXP cost structures on the market. The open-source Community Edition is free, while commercial Liferay DXP subscriptions range from $75,000 to $500,000+ per year depending on deployment model and modules.

• Liferay Community Edition (CE): $0 — free, open-source (LGPL 2.1), community support only
• Liferay DXP Subscription: $75,000 – $300,000/year — self-managed, includes 24/7 support, hotfixes, and enterprise modules (Analytics Cloud, Commerce, Audience Targeting)
• Liferay DXP Cloud (SaaS/PaaS): $90,000 – $500,000+/year — fully managed on AWS/Azure Kubernetes, includes infrastructure, CI/CD, scaling, and compliance certifications (SOC2, ISO27001, HIPAA-ready)
• Liferay Analytics Cloud add-on: +$25,000/year

Below is the full license-tier matrix and a 3-year TCO breakdown to help you benchmark Liferay pricing against Adobe, Sitecore, and Acquia.

License Tiers

TCO Breakdown (3-Year, 500K Monthly Visitors, 3 Envs)

Assumes: $150K/FTE/yr loaded cost. Self-managed includes EKS, RDS, OpenSearch, CloudFront, 3 envs. Liferay Cloud includes infra, managed services, 3 envs. Implementation lower on Cloud due to pre-built pipelines.

Extensibility Patterns: Upgrade-Safe Customization

1. OSGi Service Override (Highest Priority)

Implement same interface, higher service.ranking (default 0, max Integer.MAX_VALUE). Original service becomes unsatisfied. Example: Override UserLocalService to add custom validation on create.

2. Fragment Bundles (JSP/CSS/Language Overrides)

Create fragment bundle with Fragment-Host: com.liferay.portal.web.internal.portlet. Place overridden JSPs in META-INF/resources/ matching original path. Zero Java code, survives upgrades unless JSP API changes.

3. Model Listener / Service Wrapper

@Component(immediate=true, service=ModelListener.class) for entity lifecycle hooks. ServiceWrapper for wrapping service methods (deprecated in 7.4, prefer OSGi service override).

4. Custom REST/GraphQL Endpoints

JAX-RS (@ApplicationPath, @Path, @GET) or GraphQL (@Component(property="graphql.schema.provider=true")). Deploy as separate module — no core modification.

5. Frontend: React Widgets + Fragments

Liferay 7.4 uses React 18 + Vite for widget development. npm create liferay-widget scaffolds TypeScript React widget. Deploy as OSGi bundle via npm run deploy. Fragments (HTML/CSS/JS snippets) managed in-page via Fragments Admin — no deployment needed.

Enterprise Modules (DXP Subscription Required)

Liferay Analytics Cloud

Event-driven analytics pipeline: Liferay → Kafka (managed) → Snowflake → Looker/Tableau. Tracks page views, asset downloads, form submissions, search queries, user journeys. Not real-time — 15-min latency. PII masking via configuration. Cost: $25,000/yr add-on.

Liferay Commerce (B2B/B2C)

Headless commerce engine built on Elastic Path (acquired 2021). Supports: complex pricing (contract, tiered, volume), CPQ, subscriptions, multi-site catalogs, punchout (cXML/OCI). GraphQL Storefront API. Not a full SAP Hybris/Salesforce Commerce Cloud replacement — best for "content-led commerce" where Liferay owns the experience layer.

Audience Targeting & Personalization

Rule engine (Drools-based) + behavioral scoring. Segments: explicit (profile attributes), implicit (behavioral), predictive (ML models via Analytics Cloud). Content targeting via TargetingRule on fragments/widgets. No native A/B testing — integrate Optimizely/VWO or build via feature flags.

Forms & Workflow (Kaleo)

Visual form builder (React-based) with 40+ field types. Workflow: Kaleo designer (BPMN-lite) with scriptable nodes (Groovy/JavaScript). Supports parallel approvals, SLAs, escalation. Forms submit to Liferay objects (custom entities) or external endpoints.

Competitive Positioning: When to Choose Liferay

Choose Liferay DXP When:

• Building employee portals, partner portals, customer self-service portals — Liferay's permission model (roles, permissions, scopes, user groups, organizations) is unmatched.
• You need source code ownership for regulatory, security, or strategic reasons (no vendor can "turn off" your platform).
• You have Java/OSGi engineering talent and want to avoid proprietary lock-in.
• You need on-premises or air-gapped deployment (defense, healthcare, financial services).
• You're migrating from Liferay 6.2/7.x and want to preserve content/permission investments.

Avoid Liferay When:

• Primary use case is marketing-led websites with heavy personalization, A/B testing, journey orchestration — Sitecore/Optimizely/Adobe Target are superior.
• Team lacks Java expertise and cannot hire/retain OSGi developers.
• Need out-of-the-box marketing automation (email, lead scoring, nurture) — Liferay's is basic; integrate Marketo/HubSpot/Mautic.
• Require visual page building for marketers — Liferay Fragments are developer-oriented; no true WYSIWYG like AEM Sites or Sitecore Experience Editor.

Frequently Asked Questions

Implementation Readiness Checklist