What Shipping to the Liferay Marketplace Actually Involves
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.
| What | Risk | Practice |
|---|---|---|
| JavaScript globals | Two products define the same name | One namespaced object, or no global at all |
| CSS class names | Styles leak into or out of your markup | Prefix every class; never style bare elements |
| DOM element ids | Duplicate ids across instances | Scope to the instance root, never a fixed id |
| Configuration keys and object names | Clashes with customer entities | Prefix consistently with a short product identifier |
| Bundled libraries | A duplicate copy conflicts with theirs | Depend on what the platform provides where possible |
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.
- Document exactly what is stored, where, and why - before anyone has to ask.
- Version the shape of anything you persist, so a later release can read what an earlier one wrote.
- Never assume a fresh install; your upgrade path has to handle data from every version you published.
- Decide and state what uninstalling does, including whether data is removed or deliberately retained.
- 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.