All posts
Liferay · 13 min read · Oct 8, 2026

How to Prepare for the Liferay Associate Developer (LAD) Exam

Study plan for the Liferay Associate Developer certification covering client extensions, objects, headless APIs and tooling

If your Liferay experience is mostly OSGi modules, Service Builder and portlets, the Liferay Associate Developer exam can be a surprise. Those topics still appear, but the weight has moved to the way Liferay is built today: client extensions, Objects, headless APIs, batch provisioning and the tooling around them. Many questions are less "how does this work?" and more "which of these is correct for this deployment model?"

This post is the study approach I would give anyone preparing for it: what the exam leans on, the specific details that are easy to know vaguely and get wrong under time pressure, and how to deal with questions where more than one answer is right. Formats and versions change, so always confirm the current exam outline on Liferay's certification page and verify version-specific details against learn.liferay.com.

Start with the official learning path

Liferay's own developer learning path is the closest thing to a syllabus, and it is the right backbone for your preparation. It moves from application design and workspace tooling through Objects, frontend and backend client extensions, consuming and producing headless APIs, and finally design elements such as fragments, page templates and style books.

Work through it in order, but do not just read it. For every step, build the thing in a local workspace. The exam rewards people who have typed client-extension.yaml by hand and seen a deploy fail, because the questions sit exactly on the details that only stick once you have got them wrong.

The one idea that answers many questions: deployment models

A surprising number of questions turn on where something can run. Liferay is offered as SaaS, as PaaS and as self-hosted, and the capabilities are not the same across them. Learn this table until it is automatic.

CapabilitySaaSPaaSSelf-hosted
Client extensionsYesYesYes
OSGi modules (JARs)NoYesYes
WAR-based themesNoYesYes
REST Builder APIsNoYesYes
Groovy scripts in object validations and actionsNoYesYes
Encrypted object fieldsNoYesYes
If a scenario says SaaS, anything that deploys Java into the portal is the wrong answer.

The reasoning behind it is simple: on SaaS, you do not get to put code inside the portal's JVM, so everything custom runs as a client extension - in the browser, or in a microservice outside the portal. Once that clicks, a whole category of questions becomes a matter of elimination.

Client extension YAML: know the keys, not just the idea

Knowing what a custom element or a theme CSS client extension is will not be enough. Expect questions about the actual properties in client-extension.yaml - which key does what, which type a property belongs to, and what the default is.

yaml
my-custom-element:
    name: My Custom Element
    type: customElement
    htmlElementName: my-custom-element   # must match customElements.define()
    friendlyURLMapping: my-custom-element
    instanceable: false                  # the default
    portletCategoryName: category.client-extensions
    urls:
        - "*.js"
    cssURLs:
        - "*.css"
    useESM: true

my-headless-app:
    name: My Headless Server App
    type: oAuthApplicationHeadlessServer
    scopes:
        - Liferay.Headless.Admin.User.everything.read
Two of the most common types. Be able to read every line and say what changes if it is removed.

The frontend types each have a small set of properties that are worth memorising as a group, because questions often offer a real property from the wrong type as a distractor.

TypeProperties and facts worth knowing
customElementhtmlElementName, friendlyURLMapping, urls, cssURLs, instanceable (default false), useESM, portletCategoryName
themeCSSclayURL, mainURL, frontendTokenDefinitionJSON; a control panel scope makes it the admin theme, and only one can be active
globalCSSCompany scope; loads after the theme CSS
globalJSCompany or layout scope; scriptLocation head or bottom; scriptElementAttributes such as async
jsImportMapsEntryMaps a bare specifier to a URL so modules can share a library
themeSpritemap, themeFaviconSVG sprite map and ICO favicon for a theme
fdsCellRenderer, fdsFilterCustomise Frontend Data Set cells and filters
oAuthApplicationHeadlessServerServer-to-server, no user context
oAuthApplicationUserAgentActs on behalf of a signed-in user
instanceSettingsSets configuration by PID for an instance
The two OAuth types are a classic either/or question: does the call need a user context or not?

On the backend side, know the microservice-backed types - object actions, object validation rules, workflow actions, notification types and CAPTCHA - and the basics of a Spring Boot microservice client extension: it is built with bootJar, run locally with bootRun, exposes a /ready endpoint, and authenticates to Liferay with OAuth 2.0.

Blade and Liferay Cloud (lcp) commands

Command questions are pure recall, which makes them easy marks if you have practised and easy to lose if you have only seen them in passing. Learn what each command does and, just as importantly, which tool it belongs to.

bash
# Blade - workspace and local development
blade init my-workspace            # create a Liferay workspace
blade create -t <template> name    # create a project from a template
blade create -l                    # list available templates
blade server init                  # set up the local bundle
blade server start                 # start it (blade server run = foreground)
blade gw deploy                    # run the Gradle wrapper's deploy task
blade gw buildRest                 # generate REST Builder code
blade upgradeSourceCode            # help migrate code to a newer version

# lcp - Liferay Cloud (PaaS / SaaS)
lcp login
lcp list                           # list projects and services
lcp deploy                         # deploy to an environment
lcp log                            # stream logs
If an answer mixes a blade subcommand into lcp, or the other way round, it is wrong.

Pair the commands with the workspace layout. Know the purpose of bundles, configs (with its common, dev, local, uat and prd folders), client-extensions, modules, themes and wars, and which settings live in gradle.properties - liferay.workspace.product, liferay.workspace.environment and liferay.workspace.home.dir - versus settings.gradle, which holds the workspace plugin version.

Objects: the limits and the rules

Objects carry a lot of weight, and the questions favour specifics: field limits, which relationship types exist, what happens on delete. If you have built an application on Objects you will know most of this already; the gaps tend to be in the numbers.

  • Field types and limits: Text up to 280 characters, Long Text up to 65,000, Integer up to 9 digits, Long and Decimal up to 16, Precision Decimal without rounding, Attachment with one file per field.
  • Relationships are one-to-many and many-to-many. There is no one-to-one relationship type - a favourite distractor.
  • Deletion behaviour is set on the parent side: Cascade, Disassociate or Prevent.
  • Calculated fields: Aggregation (needs a relationship), Auto-Increment, and Formula.
  • Validations: Expression Builder, Composite Key, Groovy (not on SaaS) and client extension validations.
  • Actions: triggers such as after add, update or delete, plus standalone actions you invoke manually; types include notifications, add or update entry, webhook and Groovy.
  • Scope is company or site, and it cannot be changed after the object is published.
  • System objects such as User, Account and Organization can be extended, not deleted.
  • Object states (a picklist plus the state manager) are for simple status flows; workflow is the full engine.

Batch: file conventions and strategies

Batch appears twice: as the Batch Engine's import and export APIs, and as the batch client extension that provisions data on deploy. Both share the same vocabulary, and the questions focus on it.

json
{
  "configuration": {
    "className": "com.liferay.object.rest.dto.v1_0.ObjectEntry",
    "taskItemDelegateName": "C_Ticket",
    "parameters": {
      "createStrategy": "UPSERT",
      "importStrategy": "ON_ERROR_FAIL"
    }
  },
  "items": [
    { "externalReferenceCode": "TICKET-001", "title": "Sample ticket" }
  ]
}
A file such as 01-tickets.batch-engine-data.json. The numeric prefix controls import order.
  • Files are named *.batch-engine-data.json, and numeric prefixes (00-, 01-, ...) set the order - definitions before the entries that depend on them.
  • importStrategy: ON_ERROR_FAIL (the default) or ON_ERROR_CONTINUE.
  • createStrategy: INSERT (the default) or UPSERT; updateStrategy: UPDATE or PARTIAL_UPDATE.
  • taskItemDelegateName for a custom object is C_ followed by the object name.
  • Use external reference codes so redeploying updates records instead of duplicating them.
  • The safest way to get a correct file is to export from a working instance and edit the result.

Headless APIs: the details that separate answers

You will need to know where APIs live (/o/c/ for objects, /o/headless-delivery/v1.0/ and the other headless apps, the API Explorer at /o/api), the common query parameters, and the differences between REST and GraphQL in Liferay. A few facts come up again and again.

  • PUT replaces the whole resource and resets fields you leave out; PATCH changes only the fields you send.
  • Query parameters: page, pageSize, sort (field:asc or field:desc), filter (OData), search, fields, restrictFields, nestedFields, and nestedFieldsDepth up to 5.
  • OData filter operators: eq, ne, gt, ge, lt, le, contains, startswith, endswith, in, and, or, not.
  • Records can be fetched by external reference code at /by-external-reference-code/{erc} in REST - something GraphQL cannot do, along with invoking object actions and PATCH.
  • Server-to-server calls use the client credentials grant against /o/oauth2/token and a Bearer header; session-based calls from the browser need the CSRF token (Liferay.authToken) in the x-csrf-token header.
  • Producing APIs: Objects give you REST and GraphQL with no code; REST Builder (rest-config.yaml and rest-openapi.yaml, generated with buildRest) is not available on SaaS; a microservice can bridge APIs on any deployment model.

Don't skip the design elements

The final part of the learning path is easy to rush because it feels less like development. It still shows up. Know the difference between master pages (every page has one), page templates (a starting point that does not lock the page) and display page templates (rendering content at its own URL). Know how fragments are built - HTML, CSS, JavaScript and a configuration JSON - and how configuration values are referenced. Know that style books are tied to a theme, that Clay is the component library and Lexicon the design language, and that widget templates should not call APIs directly.

Multiple-select questions need a different technique

Some questions ask you to choose more than one correct answer. These are where most people lose marks, because a single wrong pick or a single missing pick costs you the question. They also reward precise knowledge over general familiarity - every option is usually a real Liferay concept, just not always the right one for the scenario.

  1. Read the stem for the constraint before you read the options. "On SaaS", "without code", "with a user context" and "at deploy time" each rule out whole groups of answers.
  2. Judge every option on its own as true or false for that scenario. Do not compare them with each other or try to guess how many should be right.
  3. Watch for real names in the wrong place: a property from a different client extension type, a blade subcommand offered as an lcp command, a relationship type that does not exist.
  4. Be suspicious of absolutes such as "always" and "only", and check them against what you know of the deployment models.
  5. If the question tells you how many to choose, use that count as a check on your reasoning, not as a reason to add a guess.

A practical study plan

  1. Set up a local workspace with Blade on JDK 21 and keep it running for the whole period of study.
  2. Go through the learning path one step at a time, and after each step build its example yourself - a custom element, a theme CSS extension, a batch extension that loads an object, a Spring Boot object action, a headless call with OAuth.
  3. Write a one-page summary per area in your own words, with the numbers and defaults in a separate list. Those lists are what you revise in the final week.
  4. Practise with questions after each area, not only at the end. Aim for a comfortable score before moving on, and reread the source for anything you missed rather than memorising the answer.
  5. Spend extra time on the areas that are pure recall: client-extension.yaml properties, Blade and lcp commands, object field limits, batch strategies and API parameters.
  6. In the last few days, revise the deployment model table and your lists of numbers and defaults, and do a mixed set of questions to practise switching between topics.

Two cautions. First, do not study from leaked exam questions; besides breaking the exam's terms, they teach you to recognise answers rather than understand the platform, and the exam is varied enough that it shows. Write your own practice questions from the documentation instead - the act of writing a plausible wrong answer is one of the best ways to learn the difference. Second, check the version. Liferay releases quarterly, features move out of beta, and some details in older tutorials are simply out of date.

Conclusion

The Liferay Associate Developer exam tests the modern platform: client extensions, Objects, headless APIs, batch provisioning, and the tools you use to build and deploy them. Most of the difficulty is not conceptual but in the specifics - the exact YAML keys, the commands, the limits, the defaults, and what is allowed on each deployment model. Build each piece yourself, keep lists of the numbers, learn to read every multiple-select option on its own merits, and the exam becomes a check of work you have already done.

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