I’ve been working with Atlassian tools long enough to notice a pattern: every year the platform gets more capable, more integrated, and more “enterprise-ready”… and at the same time it gets harder to keep the day-to-day experience simple for normal users.
It’s not a complaint post. It’s more of an observation and a paradox I think most admins and partners feel right now.
Atlassian is building a platform, not just apps. Jira + JSM + Confluence + Assets + Automation + Atlassian Intelligence + Analytics + Guard… each piece adds value, but also adds decisions:
more configuration surfaces
more feature flags and rollouts
more “right ways” to do something
more dependencies between products
more “this is available only on plan X”
It’s not that any single feature is bad. It’s the accumulation. Complexity isn’t shipped in one release, it grows quietly, layer by layer.
When Atlassian adds a new capability, the tool gets better. But for admins it also creates work that nobody sees:
documentation and enablement (“what is this and why do we use it?”)
governance (“who can configure it?”)
support (“why did this change?”)
training (“where did the button go?”)
integration and security review
rollout planning (sandbox, release tracks, feature rollouts)
So the paradox becomes: the platform improves, but the cost of adopting improvements rises.
Without guardrails, Jira/Confluence naturally drift toward entropy:
custom fields multiply
workflows grow “just one more status”
labels become taxonomy wars
automation becomes a spaghetti plate
and suddenly nobody trusts reporting because definitions aren’t consistent
Teams rarely do this maliciously. They’re solving local problems. But locally optimal decisions add up to globally messy systems.
Most admins know what good looks like:
minimal workflows
consistent fields
clear ownership
boring conventions
templates that make writing easy
automation that is readable and auditable
But the platform keeps offering more knobs to turn and the organization keeps asking for “just one more exception”.
So the real skill isn’t knowing what simple means. The skill is protecting simplicity while still enabling progress.
I’ve learned that “simple” doesn’t mean “no features”. It means:
one standard way to do the common thing
exceptions only when the business case is real
controlled change, not unlimited customization
A few habits that keep things sane:
start with the “why” before adding apps or new features
set a small number of standards (fields, statuses, naming)
treat automation like code (ownership, review, versioning)
measure adoption and pain, not just “features enabled”
keep onboarding docs up to date (or users will invent their own process)
How do we keep systems simple while Atlassian keeps adding power?
I don’t think the answer is “stop changing”. The answer is:
adopt features intentionally
design for humans, not for maximum capability
and accept that simplicity is something you actively maintain
Curious how others handle this. What’s your biggest source of complexity right now and what’s one rule or practice that helped you keep your Atlassian stack usable?
Im Happy to hear more about your Opinnions :)
Arkadiusz Wroblewski
4 comments