All posts
Liferay · 12 min read · Jul 25, 2026

What Shipping to the Liferay Marketplace Actually Involves

Publishing a Liferay application to the Marketplace

The first time you publish something to the Marketplace, the code is the part that is already finished. What follows is a series of realisations about everything a project engagement quietly provides: knowing the environment, being able to look at the logs, being able to ship a fix this afternoon, and being able to ask the customer what they actually meant.

None of that is available once someone downloads a package. That absence, rather than any technical requirement, is what shapes how the thing has to be built.

Everything you can no longer assume

  • The platform version, and every patch level within it that you claimed to support.
  • What else is installed, including other Marketplace items that also touch the page.
  • Whether the environment has outbound network access at all.
  • The locale, the theme, and whether anyone customised either.
  • Data volume, which will be an order of magnitude beyond your test data somewhere.
  • That a failure will ever be reported to you rather than simply uninstalled.

That last one is worth sitting with. The feedback loop for a product is mostly silence, and silence is ambiguous. It is why the burden shifts so heavily onto behaving predictably by default rather than being fixable quickly.

Every claim is a commitment

Declaring support for a range of platform versions reads like metadata and behaves like a contract. Each version in that range has to be installed, tested and retested on every release you publish, so the range is a recurring cost rather than a one-off statement.

The instinct is to claim widely for reach. The better instinct is to claim narrowly and honestly, then extend deliberately once you have the test environments to back it. A product that works flawlessly on three versions earns more trust than one that half-works on eight.

Namespace everything you put on a page

Your code now runs inside someone else's page, next to other people's code. Anything with a global name is a potential collision, and collisions in this setting produce failures that look like the platform is broken.

WhatRiskPractice
JavaScript globalsTwo products define the same nameOne namespaced object, or no global at all
CSS class namesStyles leak into or out of your markupPrefix every class; never style bare elements
DOM element idsDuplicate ids across instancesScope to the instance root, never a fixed id
Configuration keys and object namesClashes with customer entitiesPrefix consistently with a short product identifier
Bundled librariesA duplicate copy conflicts with theirsDepend on what the platform provides where possible
In a shared page, an unprefixed name is a bug waiting for the right neighbour.

It has to work before anyone configures it

An installation that produces nothing visible until several settings are filled in reads as broken, and most evaluations end there. Whatever it does out of the box should be immediately demonstrable, which makes the default configuration a product decision rather than a technical one. Sensible defaults are the single highest-leverage thing you can do for adoption.

Data you create is data they inherit

Anything your product persists becomes the administrator's problem: it appears in their backups, their storage, their audits, and eventually their questions about what it is and whether it can be deleted.

  1. Document exactly what is stored, where, and why - before anyone has to ask.
  2. Version the shape of anything you persist, so a later release can read what an earlier one wrote.
  3. Never assume a fresh install; your upgrade path has to handle data from every version you published.
  4. Decide and state what uninstalling does, including whether data is removed or deliberately retained.
  5. Provide a way to purge, because an administrator who cannot clean up will not install the next version.

Orphaned data left behind by an uninstall is the specific behaviour that makes administrators distrust third-party packages in general. Handling it well is cheap and disproportionately reputational.

Fail visibly, in their logs

You will never see the exception. The only diagnostic surface you have is what the product writes into the customer's own log, and what the interface shows when something goes wrong.

That changes how errors should be written. A message that identifies the product by name, states what it was attempting, and names the setting or condition that was wrong is worth far more here than a stack trace, because the person reading it is an administrator rather than its author. The same applies on screen: a clear statement that a data source could not be reached beats a blank panel that the customer will report as the platform failing.

The listing is the documentation most people read

The description, the screenshots and the compatibility information are not marketing around the product - for most evaluators they are the product, because they decide whether an install ever happens. Screenshots showing the default state carry more weight than any feature list, and a short statement of what it does not do prevents the installs that were always going to end in disappointment.

Beyond the listing, a short installation and configuration guide answers the questions that otherwise arrive individually. What permissions does it need, what does it store, how is it configured, how is it removed. Four questions, and answering them in advance removes most of the support load.

Keep the surface small on purpose

Every configuration option, supported version, locale and integration point is a permanent commitment to test and support. A product with a deliberately narrow surface is not less ambitious - it is one that can still be maintained after the initial enthusiasm passes. This is the same accounting as the long-term cost of any customization, except that here you are the one who pays it, on every release, forever.

Conclusion

Publishing turns a piece of code into a product, and products are defined by constraints rather than features. You cannot see the environment, cannot read the logs, cannot patch quickly, and will rarely hear what went wrong. Build for that: namespace everything, be excellent by default, version what you persist, fail with messages an administrator can act on, document what you store, and claim only the compatibility you genuinely test. The code was never the hard part.

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