All solutions
Platform Strategy · 11 min read · Oct 19, 2026

SaaS, PaaS, or Self-Hosted? Picking a Liferay Deployment Model

Three Liferay deployment models side by side, showing how control, customization and operational responsibility shift between SaaS, PaaS and self-hosted

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.

CapabilitySaaSPaaSSelf-hosted
Client extensions (UI components and external services)YesYesYes
Low-code features: Objects, fragments, page templates, workflowsYesYesYes
Custom Java modules running inside the portalNoYesYes
Classic theme packagesNoYesYes
Server-side scripts inside the portalNoYesYes
Low-level portal configuration filesNo - instance-level settings onlyYes, per environmentYes
Server and memory tuningNoPartial - within the platform's optionsFull
Direct database accessNoRestricted to the platform's toolingFull
Search engine customizationNoWithin the managed search serviceFull
Choosing when to upgradeNo - Liferay decidesYesYes
Choosing the hosting regionFrom Liferay's offered regionsFrom Liferay's offered regionsAnywhere, including on-premises
The general shape. Details of individual rows have shifted between releases and can depend on your subscription, so confirm anything critical against the current documentation and your agreement.

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.

ResponsibilitySaaSPaaSSelf-hosted
Infrastructure and operating system patchingLiferayLiferayYou
Product updates and security fixesLiferay applies themLiferay ships them, you apply themYou
Running upgrades and fixing what breaksLiferay for the platform, you for your extensionsYou, with platform toolingYou
Database and search operationsLiferayMostly Liferay; you size and configureYou
BackupsLiferayPlatform backup service; you set retention and test restoresYou
Disaster recoveryLiferay, per your agreementOptions depend on your subscriptionYou
Platform monitoringLiferayLiferay, plus metrics and logs for your teamYou
Monitoring your own code and integrationsYouYouYou
Security of your customizationsYouYouYou
Identity, single sign-on and access configurationYouYouYou
Data residencyRegion chosen from Liferay's listRegion chosen from Liferay's listAnywhere you can run it
The bottom rows never move. Whatever model you choose, your code, your integrations and your users' access are yours.

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.

ModelSkills you need in-houseSkills you can mostly skip
SaaSFront-end development, APIs and integration, building and running small services, low-code configurationPlatform internals, infrastructure operations
PaaSAll of the above, plus Java and platform development if you deploy custom modules, and release managementServer, database and search operations
Self-hostedAll of the above, plus infrastructure, database, search, networking, security patching and on-callNothing - 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 todaySaaS equivalentEffort
Custom application screensUI client extensions that call the platform's APIsModerate - the UI ports well, back-end logic needs APIs
Custom data entities built in JavaObjects, with their generated APIsModerate to high - includes data migration
Custom APIsObject APIs, or a separate service exposing your own APIModerate
Logic that reacts to data changesObject actions backed by an external serviceModerate
Scripted validation rulesBuilt-in validation rules or an external validation serviceLow to moderate
Scripts inside approval workflowsWorkflow actions handled by an external serviceModerate
Classic themeTheme CSS client extension, style books, master pages and fragmentsModerate - layout logic moves into pages
Scheduled jobs inside the portalAn external service with its own scheduler calling the APIsModerate
Low-level configuration settingsInstance settings, where an equivalent existsLow, or impossible
Overrides of built-in screens or core behaviourUsually noneRedesign or drop
The last row is where SaaS migrations stall. Find those items before you estimate anything else.

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. Team skills. Map the skills table against the people you have and can hire. The model has to survive the original team leaving.
  6. 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.
  7. 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.
  8. 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.

Contact

Let’s connect

Have a Liferay or Backend project you’d like to talk through? Fill in the form and I’ll get back to you.

Book Calendar