A mid-size logistics firm in Dubai runs its warehouse software with a team of six. One person writes code, reviews her own pull requests, and also signs off on production releases, because there is no one else to do it. A bank in Riyadh runs the opposite problem: forty engineers, three of whom are senior enough to be trusted with a production approval, and all three are already booked on other projects when an incident lands at 2am. Neither org fits neatly into 'Developer, QA, Manager, Admin.' Most software doesn't ask them to. It assumes the org chart it was built for.
This is not a theoretical gap. The GCC's tech-talent shortage is acute enough that a large majority of regional organisations report real skills gaps, and the pattern repeats globally — more than half of European firms report they cannot find qualified developers either. When senior engineering time is the scarcest resource in the building, a permission model that forces you to hire around its assumptions is itself a cost.
Why four fixed roles don't survive contact with a real org
A role-based system with four hardcoded roles makes an implicit claim: that 'who can approve a production release' and 'who can view another team's diagnostics' and 'who can see Face Off scores for their department' are all the same question, answerable by the same label. They are not. A QA lead in Abu Dhabi might need to approve staging promotions for two product lines but should never see payroll-adjacent diagnostic output from a third. A founder running a 12-person shop wears the Developer hat on Monday and the Manager hat when a client calls. Fixed roles either over-grant (give the founder QA powers she doesn't need, because the label bundles them) or under-grant (force her to log in under three accounts to get the access her actual job requires).
Corporate AI 365 doesn't ship four roles. It ships 41 discrete permissions and lets an org compose any role it needs from them — including the four consoles (Employee, Developer, QA, Manager) as starting templates, not fixed destinations.
The mechanism: permissions as atoms, roles as compositions
Each permission is a single, auditable capability: submit a plain-language problem report, view a diagnosis and its confidence score, approve a promotion from Developer to QA, approve QA to production, revert a release, connect or disconnect a git provider, view Face Off scores for a given org level, manage another user's permission set. None of these bundle automatically. A role in the system — 'Senior Backend, Payments Team' — is just a named set of permissions attached to a position in the real org hierarchy, which can itself scope what that role sees. Multi-hat is native: one person can hold two roles with two different permission sets, and the system tracks which hat approved which gate.
This matters at the approval gate specifically, because that's where the governance actually lives. Developer → QA → approval → production exists as real git branches and pull requests, and every transition between them is a permission check plus an audit record — who approved, with what confidence score attached to the diagnosis, at what timestamp. A security reviewer's first question is usually 'show me who could have pushed this to production.' With 41 atomic permissions and an org hierarchy behind them, that answer is a query, not a guess.
It's worth being honest about the cost of this design. Forty-one permissions is not a trivial surface. A system this granular can be misconfigured — an admin who grants broadly 'to be safe' recreates the over-grant problem fixed roles were supposed to avoid, just with more knobs. The templates exist precisely to counter that: start from Employee, Developer, QA, or Manager, and subtract or add individual permissions rather than building from zero. The composability is the point; it isn't an invitation to hand every new hire a custom 41-way grant on day one.
What this buys a lean Gulf team specifically
The payoff shows up at the moment that actually costs money. Large-enterprise production downtime runs to a median of roughly US$9,000 a minute by independent industry estimates — a number that makes 'wait for the one senior engineer who understands this module' an expensive default. With permissions composed this precisely, a non-senior developer can be scoped to run diagnosis and raise a fix to QA, while a senior engineer's scarce time is reserved only for the approval gate that genuinely needs judgment. The AI does the root-cause work — file, class, line, a confidence score, a proposed fix, reproducible because it's cached against a hash of the issue and the code snapshot — and a smaller set of trusted people spend their time on the decision, not the detective work.
It also means the person who notices the problem doesn't have to be an engineer at all. Someone in operations or customer service in Doha can file a plain-language report through the Employee console; the permission model decides who sees what happens next, not whether the report gets filed at all. And the trust boundary stays fixed regardless of how permissions are composed: no role, however broadly granted, can reach a live database. The system reasons over source code and a scripted schema export; if a fix genuinely needs live data, it writes a read-only query for your own developer to run, and the result never leaves your environment.
Start the free 14-day trial, no card required, at corp.dirayahai.com, and compose your first role from the 41 permissions rather than inheriting someone else's four.
Try Corporate AI 365 — connect a repository, report one real issue, and judge it by whether the answer points at the right line. Start a free trial →
Top comments (0)