Case study

Every ERP change, accounted for

Changes to the company ERP used to be made by hand, straight on the server. The ERP Change Portal takes a change from the owner's own words to a tested, approved and deployed change that the owner signs off, and nobody touches the server by hand along the way.

Wael Hanna · Laravel · Oct–Nov 2026

6Steps from request to accepted change, each one recorded
6 rolesOwner, developer, admin, supervisor, head developer and tester
180+Automated tests over the workflow, Git, releases and the mobile API
118Commits in under four weeks, from first line to live releases

Workflow

Six steps, one history

Every request moves through the same path. Everyone involved is notified at each step, anyone on the request can comment, and every step is written into the request's history.

01

Owner asks

Plain words, a priority from low to urgent, and up to five files of 10 MB.

owner
02

AI brief

Gemini rewrites it as a developer brief. The developer with the fewest open requests gets it.

AI
03

Developer builds

Edits the Test ERP inside the portal, runs the tests and hands in with a preview screen.

developer
04

AI review

Compares the owner's words with the real diffs and test runs, and reports to the admin.

AI
05

Admin decides

Approve, send back with notes, or reject with a reason. Then deploy with a rollback point.

admin
06

Owner accepts

Checks the live change and accepts it, or sends it back with what is wrong.

owner
status submitted→ ready_for_developer⇄ with_owner→ pending_admin→ approved_by_admin→ on_prototype→ on_beta→ ready_for_live→ deployed→ accepted

One page per request

Every request shows where it is on its path, what the owner asked for in their own words, the developer brief the AI wrote from it, and a full history down the side.

  • The progress line runs from submitted, brief, developer and review through prototype and beta to live.
  • The history records every hand-over, AI step, branch and approval, with who did it and when.

Roles

Who does what

Accounts come from the company mail system. A mailbox gets an ERP role in the mail admin panel, and that is the only way in. Nobody registers themselves.

owner

Files requests, answers the developer's questions, comments, and accepts or sends back the live change. Sees only their own requests.

developer

Builds the requests assigned to them in the Test ERP, runs tests and hands in. Can ask the owner, pass to a colleague or reject with a reason.

admin

Approves, sends back, rejects, reassigns, deploys and rolls back. Watches the ERP server's health.

supervisor

An owner and an admin in one person: files and accepts requests, and also approves and deploys.

head developer

A developer with the supervisor's rights, who can also assign a request to themself.

tester

Works a testing queue: starts a test, ticks a checklist made from the brief, and passes or fails with notes and screenshots.

rules the portal enforces

  • Nobody can change their own role or switch themself off.
  • The last active admin cannot be demoted or switched off.
  • A developer with open requests must hand them over first.
  • Accounts are switched off, never deleted, so history stays readable.

Developer

A workshop with walls

Developers work inside the portal, in a copy of the ERP made for testing. They get a real editor, and the portal keeps them inside the lines.

Edit, review, save, revert

A file tree and a full code editor run in the browser. Before every save the developer sees the diff, and every save can be undone.

  • Edits stay inside the Test ERP folder and touch only source files.
  • Each save is a Git commit on the request's own branch, so every change is audited without the developer having to know Git.
  • One configured test command, run from the portal, with its output kept on the request.
  • Hand-in names the screen that shows the change, and everyone gets a Preview button.

Artificial intelligence

AI that advises, never decides

AI does two jobs: it turns the owner's words into a brief a developer can act on, and it reviews the finished work against what the owner asked for. People make every decision.

The review an admin reads

Gemini gets the owner's words, the brief, the developer's notes, the real diffs and the test runs. It answers with a verdict and four lists: what is fulfilled, the gaps, the risks, and what to check.

  • The verdict is one of four: matches, partly, does not match, could not tell.
  • The admin can ask for the review again after changes.
  • AI never holds a request: after five minutes without an answer the request moves on, with a note saying why.

Release

Prototype, beta, live

The ERP's own Git repository sits under the portal. Each request lives on its own branch and climbs the stages on its own, so one change can go live without dragging others with it.

Promote one request at a time

Hand-in opens a merge request into prototype. Testers test it there, an admin promotes only that request's branch to beta, testers test again, and it is ready for live.

  • Before approval the portal checks the syntax of every changed file and blocks settings, key and certificate files.
  • The request page warns when two open requests touch the same files.
  • A clash with an earlier approval comes back to the developer with the conflict marked in the files.
  • The live step takes a database backup, runs any new migrations, deploys, and keeps a rollback point.

Operations

Testing and the server, in the same place

The portal also runs the quality gate between developers and live, and keeps watch over the ERP server itself.

Testing queue

Testers see what is ready, what needs a retest and what is not ready yet. Starting a test generates a checklist from the brief.

  • A pass needs every check marked. A fail goes straight back to the developer with notes and screenshots.
  • Testing happens twice: on prototype, then again on beta.

Server health and issues

Every fifteen minutes the portal checks the ERP server: CPU, memory, disks, the SQL agent, antivirus, the last database backup, certificate expiry, today's job cards and active sessions.

A bad reading opens a server issue. It closes itself when the check no longer sees the problem, or an admin marks it solved with a note, so the dashboard shows only what is really wrong now.

diskwarn < 20%, critical < 10%
backupwarn > 1 day, critical > 3
certificatewarn < 14 days
cpuwarn > 85%
memorywarn > 90%
reachableissue when down

On the phone, too

The company iPhone app shows the portal natively. Every button in the app calls the very same code as the web button, so the phone can never allow something the web forbids.

  • Sign-in is the mail hand-off; the app's access token lasts one day, so removing someone's role ends their access within a day.
  • Every portal notification becomes a push on the phone, and a tap opens the request.
  • If the push server is down, the portal retries a minute later and never holds a step.

Security

Safe by construction

The portal changes a live ERP, so its guard rails are built into the code, not left to good habits.

Single sign-on from the mail

The webmail signs a hand-off with HMAC-SHA256. It is valid for two minutes and can be used once. These accounts have no portal password at all.

A sandboxed editor

Developers can only edit inside the Test ERP, and only source files. Settings, keys and certificates are blocked before approval.

Production is written by deploys only

Only an admin's approved deploy writes to the live ERP, and each deploy keeps a rollback point. Untracked files such as settings and vendor code are never touched.

Limits on the mobile API

Tokens last one day, with 60 calls a minute per token and 30 sign-in attempts a minute per address.

Sign-in. One button: the person's mail account and role decide what they can do.
Requests. Filtered by where they are: new, with the developer, with an admin, in testing, live or rejected.

Decisions

Decisions worth explaining

The parts that took the most thought are mostly invisible on screen.

AI never decides, and never blocks

A deadline keeps requests moving when the AI service is slow or down, and people stay accountable for every approval.

The app reuses the web's code

Each mobile endpoint calls the same controller as the web button, so permissions and validation exist in exactly one place.

People live in the mail system

Taking a role away in one admin panel ends portal access everywhere, with no second account list to forget.

Switch off, never delete

A person who leaves keeps their name on the history they took part in, so the record stays complete.

A commit for every save

Every edit is versioned and reversible, and developers get Git's safety without having to use Git.

Promote a request, not a stage

Each change reaches beta and live on its own, so a slow request never holds a finished one back.

Issues close themselves

The server dashboard shows what is wrong now, and still keeps a log of what was done about it.

Readable glass

The interface uses a frosted-glass look, but glass is never laid on glass, and reduced-transparency settings make every panel solid.

Timeline

Built in under four weeks

From the first commit to live releases with testers and a mobile app.

First version, then the AI brief, the in-portal editor and real deploy with rollback, the same day.

Admin's three answers, AI review, priorities and attachments. First deploy to the ERP server.

Server issues, sign-in through the mail, and the supervisor role.

Git under the portal, the head developer role, the prototype → beta release flow, user and developer guides in English and Arabic.

The live step, merge requests page and test access.

Liquid glass redesign, and the testers' queue.

Mobile API for the iPhone app, and push notifications.

Live releases run on their own worker and apply every pending migration.