From a Liferay 6.2 Application to Modern Liferay: What Actually Changes
This is the inventory rather than the war story: what a 6.2 application is made of, what each piece becomes on current Liferay, and how much work that conversion actually is. The lessons from running such a project are a separate matter. What follows is the map you need before anyone gives an estimate.
One structural change explains most of the others
In 6.2, customizations were plugins built against the portal and deployed into it, sharing its classpath and lifecycle. On modern Liferay they are modules in an OSGi runtime with their own lifecycle, their own visibility rules, and explicit dependencies.
Nearly every difference below follows from that. Extension mechanisms that depended on sharing the portal's classpath had to be replaced by declared extension points, and the shift from plugins to modules is the change that determines how much of the application survives.
The conversion map
| In 6.2 | On modern Liferay | Nature of the change |
|---|---|---|
| Plugins SDK with Ant | Workspace with Gradle and a CLI | Mechanical, but every build file is rewritten |
| MVC portlets with JSPs | MVC portlets still exist | Largely portable - the most reassuring continuity |
| JSP hooks overriding core pages | No equivalent; fragments or client extensions | Redesign, and usually the largest single item |
| Service wrappers and portal properties hooks | Component-based extension points | Rewrite, with a close conceptual equivalent |
| Service Builder entities | Service Builder, generating modules | Mechanical; the model survives, the packaging changes |
| Custom fields used as a data model | Objects, with real schemas and APIs | Redesign, with genuine benefit |
| Velocity themes | FreeMarker themes and fragments | Rewrite, usually alongside a visual refresh |
| AlloyUI and portal-bundled JavaScript | Modern JavaScript tooling and the current UI library | Rewrite; nothing carries over |
| Embedded search or an external engine plugin | Elasticsearch as the standard engine | Reconfiguration, plus reindexing and query review |
| JSON web services | Headless REST and GraphQL APIs | New surface; old callers need migration |
| portal-ext.properties for everything | System Settings and per-module configuration | Split; some settings stay, many move |
The three categories that matter
For planning purposes every item in an application falls into one of three buckets, and mixing them is what produces estimates that are wrong by a factor rather than a margin.
- Mechanical: the concept survives and the packaging changes. Service Builder entities, MVC portlets and most business logic sit here. Predictable, and faster than teams expect.
- Rewrite with an equivalent: the capability exists but the mechanism is different. Service wrappers, themes, and configuration belong here. Slower, but the design is known in advance.
- No equivalent: the approach itself is gone. JSP overrides of core pages and anything depending on the shared classpath live here. These need a design decision, not a conversion, and they dominate the timeline.
Counting the third category early is the most useful estimating exercise available. An application with a handful of JSP overrides is a different project from one with ninety.
Why JSP overrides are the hard part
Overriding a core JSP was the default answer to almost any requirement in 6.2, which is why applications accumulated so many. They worked because a plugin could replace a file the portal owned - which is precisely what a module system prevents. There is no modern mechanism that does the same thing, and mapping each override to a supported replacement is a case-by-case exercise.
The work is not only technical. Many overrides encode requirements that were never written down anywhere else, so replacing them starts with establishing what they were for - and a meaningful proportion turn out to be unnecessary, which is the one piece of good news in this category.
What genuinely stays the same
Migration discussions overstate the discontinuity, which makes the work sound more frightening than it is. Several things carry across almost untouched.
- The permission model: roles, scopes and resource permissions work on the same concepts you already know.
- The content model: web content, structures, templates and the document library remain recognisable.
- The service layer pattern: local services, persistence and the generated layer are conceptually unchanged.
- Most business logic in plain Java, which moves with little more than new imports and packaging.
- The database concepts underneath, even where table structures have evolved.
Teams that assume everything changed rewrite working logic for no reason. The portable parts are the majority of the line count, even though they are the minority of the effort.
Three traps in the estimate
- Counting portlets instead of overrides. Portlets are mostly mechanical; overrides are the expensive item, and the two are not correlated.
- Treating the front end as a port. Nothing from the 6.2 JavaScript and theme layer survives, so this is new development regardless of how it is described.
- Ignoring the integrations. Anything calling the old web services needs a migration plan of its own, and those callers are frequently owned by other teams.
There is also a strategic question worth settling before the estimate rather than after. Where the customizations are shallow, incremental modernization is usually the better path. It stops being available when the third category dominates, because those items cannot be moved one at a time while the old mechanism keeps working.
A sensible sequence
The order that reduces risk most is to move the data model and services first, because they are the mechanical majority and everything else depends on them. Then rebuild the front end against the modernized services, taking the opportunity to decide which surfaces stay as portlets and which become independently deployable. Leave the overrides until last, when enough of the new system exists to judge whether each one is still needed at all.
Conclusion
Moving off 6.2 is not one migration, it is three - a mechanical repackaging, a set of known rewrites, and a smaller group of items with no equivalent that require design decisions. The first is faster than teams fear and the third is slower, which is why estimates built on a feature count are consistently wrong. Sort the application into those three categories before promising anything, and the plan mostly writes itself.