What is Joget? Features, Workflows & its Workings

Most teams don't lose time to one big thing. They lose it to a hundred small ones. A spreadsheet that four people edit and nobody fully trusts. An approval sitting in someone's inbox for three days. Two systems that don't talk, so a person copies numbers between them by hand and eventually fat-fingers one.

You already know the fix is software. But building it the usual way means joining a line. IT's backlog is long, the developers are booked out for months, and your request waits behind fifteen others that all felt urgent to someone.

So the work limps along. Slow, manual, easy to break.

That's the gap Joget steps into, and I'll cover what it is, how it works, why teams choose it, and where it actually stands apart. But before the fix, it's worth seeing why the obvious solutions keep failing.

Why the usual fixes never stick

Here's the pattern I see over and over. A spreadsheet gets messy, so someone builds a second one to track the first. Then a third to reconcile those. Nobody decided this. It just happened. And now half your operations run on files that live on one person's laptop, which is the kind of shadow IT that quietly becomes a real risk the day that person leaves.

The other route is a custom build. It works, sometimes beautifully. But it takes months, costs more than the quote, and leaves you dependent on the same developers for every future tweak. Want to add one field? Back in the queue.

So people reach for low-code tools. Reasonable move. The trap is that a lot of them generate code you can never touch again, or bury your logic inside a system you can't inspect, export, or leave. You move fast for a few weeks, then slam into a wall.

Most low-code projects don't fail loudly. They stall the moment someone needs something the tool won't allow, and quietly get abandoned.

That wall is why so many of these projects die. So what breaks the cycle? Start with what Joget really is.

What Joget is, in plain terms

Joget is an open-source, Java-based platform for building business apps without writing much code, or any at all. But calling it a no-code tool sells it short. It rolls app development, workflow automation, forms, data lists, the end-user interface, APIs, and plugin extensibility into a single stack. One place, not five stitched together.

That combination matters. Most tools pick a lane. Some are just form builders. Others are pure workflow engines with forms bolted on as an afterthought. Joget refuses to choose. It's a full application platform where the process, the data, and the screens people actually use all live together.

Here's the part I find genuinely smart, and I'll unpack it properly later. When you build an app in Joget, you're not generating a pile of code that gets frozen the second it's created. You're defining structured metadata through visual builders, which means the app stays editable long after you ship it. Change your mind next quarter? You just change it.

And it's built to serve three different people at once:

The business user builds the form and the flow. IT keeps control of access and security. And when something needs real custom logic, a developer drops into Java without leaving the platform. Nobody's fighting for the same tool.

The real value is in how the pieces fit. Here's what's under the hood.

How Joget actually works: the builders and the workflow loop

Everything starts in the App Composer. Think of it as the workshop where an app comes together. It pulls four builders into one screen, and on DX9 you also get a Theme Builder and a few add-on builders once they're installed. But those four are the core.

Now here's the piece that clicks once you see it. A Joget app runs as a closed loop. You define the process visually, map its steps to forms and plugins, then launch it from a menu (the Run Process Menu) or through an API. The engine runs it, drops tasks into the right person's inbox, and logs every action into process data and audit trails you can inspect later.

So automation isn't magic. Most automated steps are just a process node backed by a plugin. Need to hit an external system? The JSON API Tool handles REST calls, the SOAP Tool covers older XML services, and a custom Java tool covers anything weird. That's really the whole trick behind how Joget connects to the rest of your stack.

Expert Tip: Long-running processes don't sit in fragile page logic. Joget persists their state in the database through the Shark workflow engine and its SHK tables. That's why a process survives a server restart and keeps scaling instead of losing its place.

Knowing the loop is one thing. Here's the full toolkit you get out of the box.

Joget's feature set, without the fluff

Let me group the stuff that actually matters, because a raw feature dump helps nobody.

App design and UI. 

You build screens in a visual editor, no markup required. Fields can validate themselves and show or hide based on what someone typed a moment ago. And every app is responsive out of the box, so it works on a phone without you doing extra work.

Process automation. 

This is Joget's home turf. You get approvals, routing rules, and task assignment based on a person's role or the data itself. Add timers, escalations when something stalls, and email notifications at each step. There's SLA monitoring and a visual tracker so you can see exactly where a request is stuck.

Data and access. 

Forms write straight to backend tables. Dynamic lists let people sort, filter, and edit records in place. The access model is where it gets serious, with four separate layers you control independently:

• Who's allowed to sign in
• Who sees a given page
• Who can start a process
• Who can act on a specific task

Permissions run from admin down through organization, group, department, logged-in user, and anonymous. Granular, not all-or-nothing.

Integration and extensibility. 

Here's the range: REST and JSON APIs, JavaScript APIs, an API Builder that spits out OpenAPI specs, the JSON API and SOAP tools for outbound calls, SMTP, JDBC to outside databases, LDAP/AD, and SSO through SAML, OpenID Connect, and Kerberos. 

Need custom behavior? Script it in JavaScript or Groovy, or write a plugin. The plugin layer uses standard Java and dynamic OSGi via Apache Felix, which means you can load and unload plugins without restarting the server. The Marketplace fills gaps with ready plugins, templates, and add-on builders.

Deployment and scale. 

Run it on cloud, on-prem, or in containers (Docker, Kubernetes, OpenShift, Cloud Foundry, or straight from the AWS, Azure, and GCP marketplaces). It's mobile-ready and multilingual. To scale, you put several nodes behind a load balancer with a shared database and file store, optionally wire in Apache Ignite and Kafka, and watch it all through the Performance Analyzer.

Security worth noting: passwords are hashed with SHA-256 and a salt, MFA is handled through standard authenticator apps, audit trails are append-only, and Joget expects least-privilege database accounts. Not decoration. Real controls.

Expert Tip: Joget is Java-based and ships as a WAR file, supporting standard databases such as MySQL, PostgreSQL, Oracle, and SQL Server. DX9 moved onto Jakarta EE and needs Java 17 or newer, so check your server before you upgrade.

Features are table stakes, though. The real question is why teams pick Joget over a dozen similar tools.

What actually makes Joget different

The common belief is that low-code is low-code. Pick any of them, drag some boxes around, ship an app by Friday. They're all basically the same thing with different logos. Right?

Not quite. Here's what that view misses.

Most low-code tools do one of two things that come back to bite you. They generate a pile of code you can never cleanly edit again, or they bury your logic inside a proprietary system you can't inspect, can't self-host, and can't walk away from. The citizen-developer dream works great until it doesn't. You hit a wall the tool won't let you cross, and your developers end up rebuilding the whole thing from scratch. I've watched it happen more than once.

So what makes Joget different isn't the drag-and-drop. Everyone has that. It's the model underneath.

Your app is structured metadata, not frozen generated code, so it stays editable forever. The core is open source and you can self-host it, which means you can actually read the runtime and skip the lock-in (the codebase is modular and public, with pieces like wflow-core and wflow-wfengine sitting right there). And when you finally hit the no-code ceiling, the Java and OSGi plugin layer lets a developer extend the same app instead of abandoning it.

That's the real point. It isn't no-code or pro-code. It's a continuum you slide along as your needs grow.

I'll be straight about the trade-off. If what you want is the largest catalog of prebuilt SaaS connectors with zero custom work, Microsoft's Power Apps ecosystem is wider than Joget's. That's a real gap. Joget bets on openness and extensibility instead of a giant connector library, and for the teams it suits, that's the better bet.

That openness comes with one early fork: Community or Enterprise. Pick wrong and it gets expensive.

Community vs Enterprise: where the real line is

There's a myth worth killing right away. People assume Community is the toy version and Enterprise is where you get to build real apps. Wrong. Both editions build the same core: forms, lists, the UI, processes, and plugins. You can ship a genuinely useful app on the free tier.

The line isn't app-building. It's everything around running that app in a serious production setting.

On money: Community is free under GPLv3. Enterprise is commercial. If you'd rather not host it yourself, the cloud side adds managed services billed as monthly infrastructure bundles, plus On-Demand plans priced per user per month with a minimum number of seats. On-prem Enterprise pricing isn't published anywhere. You talk to sales and negotiate.

Expert Tip: Start on Community. It's perfect for learning the platform, prototyping, and running internal tools your own team can support. Switch to Enterprise the moment you need SSO or Active Directory, MFA, high availability, SLA reporting, or someone to call when it breaks. That moment is usually the day it goes live in a regulated environment.

Editions sorted. One question is left: does Joget even fit your problem? Because it doesn't fit everyone.

Who Joget is for (and who it isn't)

Not every tool fits every team, and pretending otherwise wastes everyone's time. So here's my honest read on where Joget lands.

It's a strong fit if you're one of these:

• You want an open, self-hostable platform for internal operational systems and you'd rather own your stack than rent it.
• You're workflow-heavy and you need business users and Java developers building in the same place without the app turning into an unmaintainable mess.
• You need a layer that sits between old legacy systems and modern screens, wired together through APIs, JDBC, and directory integration.

And here's who should probably look elsewhere. If you want a mostly SaaS-managed setup with a giant connector catalog and no appetite for Java or infrastructure work, a packaged tool like Power Apps will feel easier. Joget rewards teams willing to get a little technical. That's the deal.

Where it really shines is process work: approval flows, employee onboarding, service requests, case management, CRM-style apps, compliance and audit systems, internal portals. Anything with steps, roles, and a paper trail.

This isn't a niche BPM tool. Joget runs in more than 100 countries across finance, healthcare, telecom, manufacturing, and government. Telkom Indonesia handles over a million tickets a month on it, and Sunway migrated more than 300 legacy apps onto it. That's real production scale, not a demo.

Knowing it fits is step one. Getting it live without stalling is step two.

Getting started with Joget (and where Relinns fits)

The teams that succeed with Joget all do the same thing: they start small. One real problem, not a grand platform rollout. Pick a process that annoys everyone, build that, prove it works, then grow from there.

Here's the path that actually works:

Your five-step start:

That last part is the whole game. Nail one workflow, and the next five get easier because your team already knows the platform.

This is also where a partner earns their keep. Relinns is a certified Joget DX9 partner, so instead of learning the platform's quirks the hard way, you get a team that's already shipped these builds. Our CTO, Ajay, has led Joget implementations end-to-end, from the first use case to full production.

Thinking about Joget for a real process? Talk to our Joget team, and we'll help you scope the first build.

Last, the quick answers people search for right before they commit.