At SKO 2026, we shared a slide outlining the complete learning catalog available on learn.liferay.com through 2025. That slide reflects something important: Liferay education is no longer a loose collection of technical topics. It is now a structured, role-based learning ecosystem.
This blog started with this slide from Hanna Ilén at SKO 2026:
It shows the paths and all of the courses that we delivered last year in one slide.
Practitioners. Application Developers. Content Managers. Frontend Developers. Commerce Administrators.
Each path builds real capability, not just feature familiarity.
Wondering about the paths, the courses, and where they might take you?
Read on to find out...
Practitioner
Building Enterprise Websites with Liferay
This is the foundational entry point into Liferay DXP.
The course focuses on planning and implementing enterprise websites using Liferay's out-of-the-box capabilities. It addresses real-world challenges organizations face when digital tools become fragmented: data silos, security gaps, integration complexity, and inconsistent experiences.
By the end of the course, learners can:
- Map business and design requirements to Liferay features
- Make informed decisions between available platform capabilities
- Leverage low-code site-building tools effectively
- Identify when extensions are required beyond OOTB features
- Plan scalable, maintainable website architectures
It does not require programming knowledge, but it builds the architectural awareness needed to make intelligent implementation decisions.
Application Developer
This path focuses on modern platform architecture: how to extend Liferay safely, scalably, and future-proof.
Foundations of Modern Liferay Application Design
This course introduces the shift from traditional plugin-heavy development to a modular, API-driven, low-code-aware architecture.
Learners explore:
- The core principles of modern Liferay application design
- Differences between legacy extension patterns and modern approaches
- How Objects, Headless APIs, and Client Extensions work together
- Why modularity and decoupling improve maintainability and upgrades
It establishes architectural thinking before diving into tools.
Workspaces and Tooling
(Mastering Liferay Workspaces and Tooling on Learn)
This course is the operational foundation for developers.
It covers:
- Liferay Workspace structure and lifecycle
- Blade CLI usage
- Development accelerators
- Third-party tool integration
- Multi-environment deployment (local, PaaS, SaaS)
- Team-based development strategies
If you're writing code for Liferay, this is the baseline skillset.
Data Modeling with Liferay Objects
(Mastering Data Modeling with Liferay Objects on Learn)
This course focuses on Liferay's low-code application model.
Learners build and manage:
- Custom data models
- Object relationships
- Validations and business logic
- Page-builder-driven object experiences
- Security and permissions
- Environment promotion and migration
- API integrations
- Client extension enhancements
It bridges business-driven data modeling with technical extensibility.
Client Extensions (CX)
Client Extensions are the core modern extension mechanism in Liferay.
Foundations of Client Extensions
This course introduces the client extension paradigm:
- Why extensions live outside the portal container
- How they interact exclusively through APIs
- When to use CX instead of traditional plugins
- Deployment compatibility across SaaS, PaaS, and Self-Hosted
It establishes the "why" and "when" of CX.
Backend Client Extensions
(Mastering Liferay Backend Client Extensions)
This course goes deeper into backend-focused use cases:
- Microservice, batch, and configuration extensions
- OAuth2-secured communication
- Bridging APIs between Liferay and external systems
- Workflow and object framework extensions
- Data and configuration migration strategies
It emphasizes decoupling and scalability.
Frontend Client Extensions
(Mastering Liferay Frontend Client Extensions)
This course focuses on frontend customization:
- Custom elements and responsive UI
- Theme overrides and branding
- Resource loading and caching configuration
- Integration with Liferay's design system
- Selective resource application for performance optimization
It enables modern UI customization without modifying core.
Headless API Track
Foundations of Liferay Headless APIs
This course introduces Liferay's REST and GraphQL frameworks:
- Exploring versioned APIs
- Service access policies
- Secure API configuration
- Authorization flows
- API production vs. consumption fundamentals
It establishes the architectural model behind headless Liferay.
Producing Headless APIs
(Mastering Producing Liferay Headless APIs)
Here, learners implement APIs using:
- Liferay Objects (no-code generation)
- REST Builder (code generation)
- Microservice client extensions (bridging APIs)
The course teaches when to use each method and how to extend or restrict OOTB endpoints for specific use cases.
Consuming Headless APIs
(Mastering Consuming Liferay Headless APIs)
This course shifts to integration and frontend interaction:
- Secure API connectivity
- Query parameters for filtering and sorting
- CRUD operations
- Batch endpoints for bulk operations
- System-to-system integrations
It focuses on real integration patterns.
Design and Frontend
Design Elements
(Mastering Liferay Design Elements)
This course centers on cohesive digital experiences:
- Themes, master page templates, and style books
- Modular design components
- Layout control and structure
- Accessibility standards
- Responsive design
- Brand consistency enforcement
It provides the structural backbone of Liferay's design system.
Foundations of Liferay Frontend Development
This course introduces:
- Liferay's frontend architecture
- Integration between client extensions and design elements
- Headless API data visualization patterns
- Performance-aware frontend decision making
It connects web standards to Liferay's platform architecture.
Building Frontend Applications with JavaScript in Liferay
This is the most implementation-focused frontend course.
It covers:
- JavaScript toolchains and bundlers
- React and Clay component-based development
- Dependency sharing across custom elements
- Responsive layouts
- Headless API data retrieval
- Wrapping custom elements in fragments for reuse
It's where composable architecture becomes practical.
Content Manager Path
This path focuses on strategy, governance, and experience design.
Foundations of Content Management
This course provides:
- Strategic content modeling
- Information architecture planning
- Taxonomy and asset library organization
- Lifecycle awareness
- Role-based content security
It is the non-technical starting point for content strategy.
Pages and Navigation
Learners implement:
- User-centered information architecture
- Page hierarchies
- Page templates
- Navigation menus
- SEO-aware structure design
It focuses on site usability and discoverability.
Assets and Content
This course dives into:
- Web Content vs. Documents & Media
- Structured content modeling
- Display strategies
- Governance best practices
- Reusability planning
It answers the "how do we organize this properly?" question.
Publishing Tools and the Content Lifecycle
This course focuses on:
- Workflow configuration
- Publications vs. Staging
- Review and approval strategies
- Collaboration tools
- Analytics feedback loops
It addresses operational governance.
Personalized Experiences
Learners build:
- Static and dynamic segments
- Behavior-driven personalization
- Analytics-integrated strategies
- Site experiences per segment
- Commerce-aware personalization models
It moves beyond publishing into targeted delivery.
Content Search
This course covers:
- Search indexing fundamentals
- Search experience building
- Result tuning
- Discoverability optimization
- Troubleshooting search issues
It ensures content doesn't get lost.
Search Engine Optimization with Liferay
This course focuses on on-page SEO:
- Meta configuration
- SEO-friendly structures
- Performance analysis
- Analytics integration
It ties discoverability to measurable outcomes.
Commerce Administrator Path
Commerce extends Liferay from experience platform to transactional system.
Foundations of Liferay Commerce
This course introduces:
- Commerce architecture
- Integration with CMS and DAM
- B2B vs B2C models
- Implementation strategy planning
It sets the conceptual baseline.
Commerce Users and Accounts
Covers:
- Account modeling (B2B and B2C)
- Organization hierarchies
- Roles and permissions
- Sales team alignment
- Self-service enablement
Product Management
Focuses on:
- Catalog strategy
- Product types and configuration
- External system integration
- Multi-system synchronization
- Data governance
Inventory Management
Covers:
- Warehouse modeling
- SKU lifecycle management
- Low-stock automation
- ERP/WMS integration strategies
- Multi-channel availability planning
Price Management
Learners implement:
- Base and custom price lists
- Eligibility rules
- Promotions and discounts
- Shipping calculations
- Tax strategies
- Tiered pricing
- Multi-currency support
- External pricing integrations
Order Management
Focuses on:
- Order lifecycle control
- Custom checkout logic
- Workflow extensions
- Shipping complexity
- Notifications and self-service
- Multi-system synchronization
Storefronts
Covers:
- Channel configuration
- Product discovery
- Checkout design
- Post-purchase experiences
- B2B and B2C storefront strategy
A Note on the Case Study Model
Nearly all technical and business tracks use a consistent fictional business scenario to tie the material together. Rather than isolated feature demonstrations, each course applies concepts to a cohesive implementation journey. That continuity helps learners understand how each capability contributes to a fully developed digital experience.
Final Thoughts
Through 2025, the Liferay Learn catalog reflects a clear architectural philosophy:
- Modular
- API-driven
- Low-code aware
- Deployment-model agnostic
- Upgrade-safe
- Scalable across experience and commerce use cases
This is no longer "feature training."
It's platform architecture training.
The 2025 catalog establishes a structured, role-based foundation that spans website implementation, application architecture, content strategy, frontend development, and commerce operations. Each path builds real, production-relevant capability.
And this is only the beginning.
The roadmap for 2026 includes significant updates and expansion across multiple tracks, with new courses designed to go deeper into advanced implementation patterns and emerging platform capabilities. If you haven't visited learn.liferay.com recently, it’s worth checking back regularly because the catalog is actively evolving.

