SaaS, PaaS, or Self-Hosted? Picking a Liferay Deployment Model
A team signs up for Liferay SaaS because nobody wants to run search infrastructure again. Two weeks into the project, someone opens the old codebase: forty custom modules, an integration that syncs users to a CRM from inside the portal, scripts embedded in approval workflows, a custom theme, and a reporting tool that reads the database directly. None of it can run on SaaS. The project plan was written for a migration. What's actually needed is a rebuild.
The opposite story is just as common. An organization chooses self-hosted for full control, ships a heavily customized portal, and three years later is still on the release it launched with, because every upgrade means rebuilding custom code, retesting everything, and scheduling a weekend of downtime. Control was never the problem. The bill for it was.
The deployment model is usually treated as a hosting decision. It's really a decision about what you're allowed to build, who owns which risks, and how expensive it will be to change your mind. This article compares the three models on those terms.
Three models, one product
All three run the same product, Liferay DXP. The difference is where the line sits between what Liferay operates and what you operate, and that line also decides what kind of custom code can run inside the platform.
- SaaS: Liferay runs everything - infrastructure, database, search, backups and upgrades. You configure and extend the platform, but only through client extensions: custom code that runs in the browser or as separate services outside the portal. In exchange, upgrades are no longer your project; Liferay moves the platform forward on its own schedule.
- PaaS (Liferay Cloud): Liferay runs the infrastructure and gives you a set of managed environments (typically development, UAT and production). Your team owns the code and configuration deployed into them, including custom Java modules, and decides when to upgrade. You work within the services the platform provides rather than designing your own infrastructure.
- Self-hosted: you run everything - servers or containers, database, search, load balancing, backups, monitoring and upgrades. You can customize anything the product supports. Every one of those choices is also yours to maintain.
What you can customize where
The rule underneath almost every row of this table is simple: on SaaS, your code doesn't run inside the platform itself. On PaaS and self-hosted, it can. That one difference drives most of the trade-offs that follow.
| Capability | SaaS | PaaS | Self-hosted |
|---|---|---|---|
| Client extensions (UI components and external services) | Yes | Yes | Yes |
| Low-code features: Objects, fragments, page templates, workflows | Yes | Yes | Yes |
| Custom Java modules running inside the portal | No | Yes | Yes |
| Classic theme packages | No | Yes | Yes |
| Server-side scripts inside the portal | No | Yes | Yes |
| Low-level portal configuration files | No - instance-level settings only | Yes, per environment | Yes |
| Server and memory tuning | No | Partial - within the platform's options | Full |
| Direct database access | No | Restricted to the platform's tooling | Full |
| Search engine customization | No | Within the managed search service | Full |
| Choosing when to upgrade | No - Liferay decides | Yes | Yes |
| Choosing the hosting region | From Liferay's offered regions | From Liferay's offered regions | Anywhere, including on-premises |
The customizations people forget
Nobody is surprised that custom Java modules don't run on SaaS. The surprises come from smaller things that have stopped being thought of as customization at all:
- Configuration settings. A long-running portal often has dozens of low-level settings someone added years ago. On SaaS, only the settings exposed at instance level can be changed.
- Scripts in unexpected places. Approval workflows and data validation rules sometimes contain embedded scripts. They rarely show up in a code review, and they're the ones that get missed in an inventory.
- Small overrides of built-in behaviour. Tweaks to how a standard screen renders or how a core service behaves rarely have a direct replacement. They need a redesign, not a port.
- Search tuning. Custom search engine configuration on a self-hosted cluster may not carry over to PaaS and won't carry over to SaaS. Built-in tools such as search blueprints and synonym sets cover some of the same ground through the UI.
- Direct database consumers. Reporting tools, data exports and "just one quick query" scripts that read the portal's tables directly. They live outside the codebase, so they're easy to miss, and on SaaS they have to move to APIs or exports.
Who does what
The capability table tells you what you can build. This one tells you what you sign up to run. It's the typical split, not a contract: support boundaries, SLAs and what counts as "included" vary by agreement, so check yours line by line.
| Responsibility | SaaS | PaaS | Self-hosted |
|---|---|---|---|
| Infrastructure and operating system patching | Liferay | Liferay | You |
| Product updates and security fixes | Liferay applies them | Liferay ships them, you apply them | You |
| Running upgrades and fixing what breaks | Liferay for the platform, you for your extensions | You, with platform tooling | You |
| Database and search operations | Liferay | Mostly Liferay; you size and configure | You |
| Backups | Liferay | Platform backup service; you set retention and test restores | You |
| Disaster recovery | Liferay, per your agreement | Options depend on your subscription | You |
| Platform monitoring | Liferay | Liferay, plus metrics and logs for your team | You |
| Monitoring your own code and integrations | You | You | You |
| Security of your customizations | You | You | You |
| Identity, single sign-on and access configuration | You | You | You |
| Data residency | Region chosen from Liferay's list | Region chosen from Liferay's list | Anywhere you can run it |
Upgrades and cadence
Liferay ships quarterly releases, with some designated for longer-term support (check the current support policy, because the terms have changed over time). How that cadence lands on you depends entirely on the model.
On SaaS, you don't choose. The platform moves forward and your extensions have to keep working against it. That sounds risky, but it's what makes the model work: client extensions only use public APIs and documented extension points, which change far less than the platform's internals. The responsibility you keep is testing your extensions against new releases in a non-production environment before production gets them.
On PaaS and self-hosted, you choose, and that freedom is the most common way organizations end up years behind. Each skipped release makes the next upgrade bigger. On PaaS the platform makes the mechanics easier, but the real work is the same as self-hosted: rebuilding custom modules against new APIs, retesting, and fixing what moved. If your portal is several major versions behind, the gap may be closer to a re-platforming than an upgrade, and the deployment model decision should be part of that project rather than an afterthought.
Backups and disaster recovery
On PaaS, production environments get automatic backups by default, and the database is replicated for resilience; non-production environments don't get the same treatment by default. That's a good baseline, but a backup you've never restored is a hope, not a plan. Restore a production backup into a test environment on a schedule and time how long it takes. Cross-region disaster recovery is a separate question from backups, and whether it's available, and what it costs, depends on your subscription.
On self-hosted, all of this is yours: database backups, the document store (often forgotten when it lives separately from the database), the search index (usually rebuildable, if you can afford the time it takes), and a tested recovery procedure.
Security, compliance and data residency
With SaaS and PaaS, you inherit Liferay's infrastructure controls and certifications, which can save months of audit work, but you also inherit its choices. Regions are limited to what's offered, and network topology is what the platform provides. If your regulator or security team needs a specific country, a private network link, customer-managed encryption keys or an isolated environment, check whether the managed offerings support it before anything else. Self-hosted is sometimes chosen not because anyone wants to run the platform, but because it's the only model that satisfies a compliance requirement.
Where the money goes
Prices vary by contract and change over time, so the useful comparison is the structure of the cost, not the number on the quote. Every model pays for three things: the subscription, the infrastructure, and the people. What changes is which of those appears on an invoice and which you pay for in salaries and overtime.
- SaaS bundles platform, infrastructure and operations into the subscription. The visible cost is highest relative to the others, and the hidden cost is lowest - with one exception: anything you can't build as a client extension either becomes a separate service you host and pay for, or a requirement you drop.
- PaaS bundles infrastructure and platform operations, sized by environments and resources. You still pay people to build, deploy and upgrade, and upgrades on a heavily customized portal are real projects. Extra environments or larger resources usually cost extra.
- Self-hosted has the smallest subscription line and the largest people line: operations, database administration, search, security patching, on-call cover, backup storage, a disaster recovery site and monitoring tools. Comparing a self-hosted quote with a SaaS quote without costing those roles is comparing the wrong things.
The other cost that rarely makes it into the comparison is customization debt. Every custom module, override and embedded script adds upgrade work for as long as it lives, and that cost grows faster on PaaS and self-hosted because they let you build more of it. The Hidden Cost of Customizations in Enterprise Portals goes into where that cost hides. For this decision, the short version is: a model that lets you customize everything is only cheaper if you don't.
Team skills
Each model needs a different team, and a mismatch between the model and the team is where projects get hurt.
| Model | Skills you need in-house | Skills you can mostly skip |
|---|---|---|
| SaaS | Front-end development, APIs and integration, building and running small services, low-code configuration | Platform internals, infrastructure operations |
| PaaS | All of the above, plus Java and platform development if you deploy custom modules, and release management | Server, database and search operations |
| Self-hosted | All of the above, plus infrastructure, database, search, networking, security patching and on-call | Nothing - and that's the point |
A team of experienced Java platform developers will be frustrated on SaaS, at least at first. A team of front-end developers will struggle to maintain forty custom modules on PaaS. Choose the model your organization can sustain for years, not the one that fits the person who wrote the proposal.
Moving between models
The common direction is self-hosted to PaaS to SaaS, towards less operational work. The cost of each step is very different.
Self-hosted to PaaS
This is mostly repackaging. Custom code and configuration move into the managed environments, and the database and documents are imported. What breaks is anything that relied on owning the infrastructure: custom server configuration, monitoring agents, files written to local disk, scheduled jobs running on the host, extra services running next to the portal, and anything that connects to the database directly. Inventory those first.
PaaS to SaaS
This is the expensive step, because everything that runs inside the platform has to be rebuilt outside it, as client extensions. Some customizations have a clean equivalent. Some don't, and the honest answer for those is a different design or a dropped requirement.
| Customization today | SaaS equivalent | Effort |
|---|---|---|
| Custom application screens | UI client extensions that call the platform's APIs | Moderate - the UI ports well, back-end logic needs APIs |
| Custom data entities built in Java | Objects, with their generated APIs | Moderate to high - includes data migration |
| Custom APIs | Object APIs, or a separate service exposing your own API | Moderate |
| Logic that reacts to data changes | Object actions backed by an external service | Moderate |
| Scripted validation rules | Built-in validation rules or an external validation service | Low to moderate |
| Scripts inside approval workflows | Workflow actions handled by an external service | Moderate |
| Classic theme | Theme CSS client extension, style books, master pages and fragments | Moderate - layout logic moves into pages |
| Scheduled jobs inside the portal | An external service with its own scheduler calling the APIs | Moderate |
| Low-level configuration settings | Instance settings, where an equivalent exists | Low, or impossible |
| Overrides of built-in screens or core behaviour | Usually none | Redesign or drop |
Logic that used to run inside the platform is the typical case. On PaaS it's code in a module. On SaaS, the same behaviour becomes an external service that Liferay calls when the event happens. The logic itself is often similar. What changes is everything around it: the call happens over the network, it can fail independently of the portal, it needs its own hosting, logging and retries, and it can't share a database transaction with the change it reacts to. Processes that relied on that have to be rethought.
Before estimating a move, inventory what you actually have:
- The number of custom modules, and which of them override or change built-in behaviour.
- Custom data entities and custom APIs, and every system that consumes them.
- Scripts in workflows, validation rules and scheduled jobs - including those stored in the database rather than in the codebase.
- Theme and front-end customizations.
- Low-level configuration settings that differ from the defaults.
- Every external tool that reads the database directly.
Going the other way
Moving from SaaS to PaaS or self-hosted is much easier on the code side, because client extensions run on every model. That's an argument for building client-extension-first even when you're self-hosted today: it keeps the SaaS option open, and it makes every upgrade smaller in the meantime. The hard part of leaving SaaS is data and operations, not code.
A decision checklist
Work through these in order. The early questions can rule a model out entirely, which saves arguing about the later ones.
- Compliance and residency. Do you need a specific country, network isolation, customer-managed keys or on-premises hosting? If the managed offerings can't meet it in writing, the decision is made.
- Existing customizations. Inventory them, then sort every item into: works as a client extension, needs a redesign, or has no equivalent. A long "no equivalent" list rules out SaaS unless the business will drop those requirements.
- Infrastructure needs. Do you need custom monitoring agents, specific search engine plugins, extra services beside the portal, or direct database access? If yes, PaaS may not fit either.
- Upgrade track record. Be honest. If past upgrades slipped by years, a model where Liferay upgrades for you may be worth more than the control you give up.
- Team skills. Map the skills table against the people you have and can hire. The model has to survive the original team leaving.
- Cost structure. Compare subscription, infrastructure and people for each model over several years, including upgrade projects and on-call cover. Don't compare a quote with a quote.
- Integrations. List every system that talks to the portal and how. Anything that reads the database or depends on code inside the platform needs a new path on SaaS.
- Future direction. Decide which model you want in three years, and make sure new work moves towards it - usually by building new features as client extensions, whatever you choose today.
Conclusion
SaaS, PaaS and self-hosted are the same product with the line drawn in different places. SaaS takes operations and upgrades off your hands, but only client extensions run there, so it suits organizations with few legacy customizations or the appetite to rebuild them. PaaS keeps custom code inside the platform and the timing of upgrades in your hands while Liferay runs the infrastructure. Self-hosted gives you everything, including every responsibility. Decide on compliance first, inventory your customizations honestly, cost the people as well as the subscription, and whichever model you pick, build new work as client extensions so the next move is a choice rather than a rewrite.