Why Enterprise Software Makes Simple Things Complicated
Imagine you are a software developer at one of the big enterprise tech companies and they ask you to implement “Hello, World.”
Simple, right? You have been writing code since you were a teenager. You could do this in your sleep. Here is what the internal platform team has prepared for you.
try:
if (
client_license_tier == "ENTERPRISE_PLUS"
and volume_discount_enabled
and not service_credits_exhausted
and deployment_target in APPROVED_CLOUD_REGIONS
and geography not in EXCLUDED_GEOGRAPHY_LIST
and fiscal_quarter != "Q3_BILLING_LOCKOUT_WINDOW"
and month_end_promotional_voucher_active
and compliance_framework in ["ISO27001", "SOC2_TYPE2", "The_Other_One_Nobody_Can_Spell"]
and mfa_posture_score >= ACCEPTABLE_MFA_POSTURE_THRESHOLD
and not tenant_flagged_for_legacy_billing_dispute
and active_support_contract
and support_tier in ["Premier", "Unified", "GoldPlus", "PlatinumUltraElite"]
and not awaiting_annual_license_reconciliation
and feature_flag_enabled("OUTPUT_SUBSYSTEM_V2_PREVIEW_STABLE_RELEASE_CANDIDATE")
and user_consented_to_updated_terms_version >= 47
and telemetry_opt_in_confirmed
and prepaid_credits_balance > 0
and not account_frozen_pending_routine_review
):
if (
workload_classification != "RESTRICTED"
or (workload_classification == "RESTRICTED"
and restricted_workload_override_approved
and override_ticket_not_older_than_days(30)
and override_approver in AUTHORISED_OVERRIDE_APPROVERS_GLOBAL_LIST
and not override_approver_currently_on_leave)
):
print("Hello, World.")
else:
raise PermissionError(
"Output suspended pending override review. Please raise a P2 ticket "
"with your Designated Technical Account Manager, referencing your "
"Organisation GUID, Tenant Correlation ID, and the phase of the moon."
)
else:
raise LicenseError(
"One or more eligibility conditions unmet. Please review your entitlement "
"matrix, validate your compliance posture score, confirm your support tier "
"aligns with the expected GoldPlus-or-above threshold, ensure your feature "
"flag is set to PREVIEW_STABLE and not STABLE_PREVIEW, which are different "
"things for reasons we cannot discuss, and resubmit after the next billing "
"cycle closes. If the issue persists, refer to KB4839201-REV-F. "
"The workaround is to reinstall."
)
except Exception as e:
if (
active_support_contract
and support_tier == "PlatinumUltraElite"
and diagnostic_logging_upgrade_purchased
and not logging_quota_exhausted
and log_retention_policy != "EPHEMERAL_ZERO_DAY"
):
log.error(f"[REDACTED FOR COMPLIANCE] An error may (or may not) have occurred. "
f"Reference ID: {generate_opaque_guid()}")
else:
pass # you didn't pay for errors - upgrade you cheapskate45 minutes of debugging later, you discover that the feature flag is set to STABLE_PREVIEW instead of PREVIEW_STABLE. These are different things. The documentation does not explain why. There is a KB article. The workaround is to reinstall. If you have ever worked inside a large enterprise software platform and felt a twinge of recognition reading that, you are not alone, and the reason it feels familiar is worth understanding properly.
Somewhere, a Solutions Architect is polishing a slide deck about how this architecture “scales with your business needs.”
This is not a story about one bad platform or one incompetent team. It is a story about what happens to software when nobody is responsible for the experience of the whole, and it plays out in enterprise technology organisations with enough regularity that it deserves a proper explanation.
1. It Printed Text to a Screen
All it needed to do was print six characters and a punctuation mark to standard output, a task that every programming language on earth achieves in a single line and most of them teach on day one. And yet the above is not a caricature assembled from thin air; it is a recognisable portrait of how enterprise software platforms actually behave when enough teams have layered enough reasonable-sounding requirements on top of each other over enough years.
Nobody sat down and designed this, and that is perhaps the most important thing to understand about it. There was no architecture review where someone stood at a whiteboard and said “and here, in the billing lockout window check, is where we will break the developer experience forever.” What happened instead was quieter and considerably harder to fix: every team added one condition, one guardrail, one compliance obligation, and none of them were wrong to do so in isolation. The license check made sense to the licensing team. The MFA posture score made sense to the security team. The fiscal quarter lockout made sense to whoever got burned by a surprise revenue recognition problem in Q3 three years ago. The problem was not any individual decision but the fact that nobody ever stood back and looked at what the whole thing had become.
2. How Enterprise Software Complexity Accumulates
There is a particular pattern in large organisations where complexity accretes rather than gets designed, and each layer arrives in response to something real. A compliance requirement gets encoded into the platform. A billing dispute creates a new flag. A security incident produces a new posture threshold. None of these additions are inherently unreasonable, and each team that adds them is acting in good faith within their own mandate. What is missing is the person whose mandate includes the whole, someone who is accountable not for whether the compliance check is technically correct but for whether the resulting developer experience is functional for the engineer who just needs to print something to a screen. In most enterprise organisations that person either does not exist or does not have the authority to remove things, only to add them, and the result is that the platform becomes a sedimentary record of every incident, audit finding, and commercial arrangement the company has ever had, all of it faithfully encoded in conditional logic and exposed directly to the engineer who arrived at 9am wanting to ship a feature.
3. The Feature Flag That Broke the Developer Experience
STABLE_PREVIEW and PREVIEW_STABLE are, apparently, different things, and this detail is not just funny; it is diagnostic. It tells you that the system has grown beyond the point where any individual can hold its full state in their head, which means it has also grown beyond the point where it can be maintained with any consistency. When two strings that are obvious inversions of each other mean different things and the difference is not documented, you are looking at a system that has outgrown its own authors. The KB article exists. The workaround is to reinstall, which is the enterprise platform equivalent of “have you tried turning it off and on again,” delivered with a straight face and a reference number.
4. Why Open Source Keeps Winning on Developer Experience
The reason open source software consistently wins developer mindshare is not primarily about price, though that matters, and it is not primarily about transparency, though that matters too. It is about the absence of this kind of accumulated obligation. When you install an open source library and call a function, the function either works or it does not, and if it does not, the error message tells you why in plain language and the source code is there to read. Open source projects tend to be ruthless about removing things that do not serve their users because their users can leave instantly and the maintainers know it. Commercial enterprise platforms accumulate conditions because the switching cost is high enough that users cannot easily leave, and so each additional layer of complexity becomes politically survivable in a way it would not be if the customer had a genuine alternative available by lunchtime. The sharper irony, though, is what happens when organisations try to escape this by building internal developer platforms. If your internal platform has accumulated the same entitlement matrices, the same opaque flag naming conventions, and the same “raise a P2 ticket” error handling as the vendor software it was meant to replace, you have not solved the enterprise software complexity problem. You have just become the vendor, without the sales team to at least take your developers out to lunch while doing it to them.
5. Fixing Enterprise Developer Experience Starts With One Role
Simple outcomes should not require an entitlement matrix, a phase-of-the-moon check, and a mild existential crisis to achieve. The test for any platform is not whether the architecture diagram looks impressive on a slide but whether a competent developer can accomplish a straightforward task without spending 45 minutes debugging a flag name that is a palindromic anagram of itself. When the Solutions Architect finishes polishing that deck, someone in the room should be allowed to ask: “Can a developer print ‘Hello, World’ without a support ticket?” If the answer is complicated, that is the only information the room needs.
The fix is not a rewrite. It is the deliberate appointment of someone whose job is to own the developer experience of the whole platform, with the authority to remove conditions and not just add them, and with a success metric tied to developer productivity rather than compliance coverage. That person needs to be able to walk into the room where the next reasonable guardrail is about to be added and ask what it will cost the engineer on the other end before it gets merged. Most organisations have plenty of people who can add a condition to the if-statement. Almost none of them have someone whose performance review depends on how short that if-statement is.
If this felt uncomfortably familiar, you are probably working on the right problem. The first step is usually just admitting that the entitlement matrix has become the product.