All posts
Liferay · 12 min read · Nov 1, 2026

From a Liferay 6.2 Application to Modern Liferay: What Actually Changes

Mapping Liferay 6.2 concepts to their modern equivalents

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.2On modern LiferayNature of the change
Plugins SDK with AntWorkspace with Gradle and a CLIMechanical, but every build file is rewritten
MVC portlets with JSPsMVC portlets still existLargely portable - the most reassuring continuity
JSP hooks overriding core pagesNo equivalent; fragments or client extensionsRedesign, and usually the largest single item
Service wrappers and portal properties hooksComponent-based extension pointsRewrite, with a close conceptual equivalent
Service Builder entitiesService Builder, generating modulesMechanical; the model survives, the packaging changes
Custom fields used as a data modelObjects, with real schemas and APIsRedesign, with genuine benefit
Velocity themesFreeMarker themes and fragmentsRewrite, usually alongside a visual refresh
AlloyUI and portal-bundled JavaScriptModern JavaScript tooling and the current UI libraryRewrite; nothing carries over
Embedded search or an external engine pluginElasticsearch as the standard engineReconfiguration, plus reindexing and query review
JSON web servicesHeadless REST and GraphQL APIsNew surface; old callers need migration
portal-ext.properties for everythingSystem Settings and per-module configurationSplit; some settings stay, many move
Read the third column first - it is what drives the estimate.

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.

  1. 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.
  2. 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.
  3. 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.

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