All posts
Architecture · 12 min read · Apr 12, 2026

From Manual Processes to Self-Service Portals: What Actually Changes Technically

Technical obligations introduced by a self-service portal

The reasons organisations move from manual processes to self-service are rarely in dispute. What is under-discussed is the engineering delta: what the team actually has to build and operate that nobody had to before. A shared spreadsheet and an email chain are a system with no identity model, no explicit state machine, and no failure modes - because a human absorbs all of them. A portal cannot absorb anything it was not told about.

The result is that the technical scope of these projects is consistently underestimated, not because the features are hard, but because a long list of implicit responsibilities becomes explicit at once. It is worth naming them.

The schema stops being optional

A spreadsheet has an implied schema that drifts. Columns get added for one exception, dates are typed in three formats, and the same entity appears under two names. None of this causes an error, because the interpretation lives in someone's head.

The moment that data becomes records, every ambiguity has to be resolved: which fields are mandatory, what a valid value looks like, which records relate to which. This is usually the first hard conversation of the project, and it surfaces genuine business disagreements that the spreadsheet was hiding. Budget time for it as analysis work rather than treating it as data entry.

Identity becomes load-bearing

In a manual process, identity is social. Everyone knows who sent the email and whether they were allowed to. In a portal, identity is infrastructure, and it arrives with a set of questions that have no manual equivalent.

  • How do external users get accounts, and who approves them?
  • What happens when someone acts on behalf of an organisation rather than themselves?
  • How is delegation handled when the usual approver is on leave?
  • What happens to in-flight items when a user leaves or changes department?
  • Which data is visible to a colleague in the same organisation, and which is not?

Onboarding external users is typically the largest piece of unplanned work in these projects. The manual process never needed it, so it appears nowhere in the requirements, and it is not small.

Authorisation replaces access

With a shared file, access control is possession: if you can open it, you can see all of it. With records, authorisation is per-row and per-action, and the rules are usually more nuanced than anyone expects - the submitter sees their own items, a reviewer sees items in their queue, a manager sees their whole department, an auditor sees everything but can change nothing.

These rules must be enforced in the service layer, not in the interface. Hiding a button is presentation; refusing a request is security. This distinction is the source of a large share of the permission bugs that surface late in portal projects, because the two look identical during a demo.

The process becomes an explicit state machine

In a manual process, the state of a request is inferred from the last email. In a portal, state is a field with a defined set of values and defined transitions between them, and every one of those transitions has to be specified: who can perform it, what must be true first, and what it triggers.

Manual artefactSystem counterpartNew obligation it creates
A row in a shared fileA record with an ownerSchema, validation, referential integrity
Knowing who sent itAuthenticated identityRegistration, delegation, joiner and leaver handling
Access to the filePer-record authorisationRules enforced server side and tested
The last email in the chainAn explicit status and transitionsA state machine plus an audit trail
A person chasing peopleNotifications and remindersTemplating, scheduling, retries, and volume control
Re-keying into another systemAn integration callIdempotency, retries, reconciliation
A monthly pivot tableA report or dashboardA read model that does not strain the live database
Each manual convenience converts into a named engineering responsibility.

Notifications become a system you own

Chasing is a human activity that scales badly and is therefore one of the main reasons for the project. Automating it is easy; automating it well is not. The failure mode is volume: a system that emails on every event trains its users to ignore it within a fortnight, which recreates the original problem with extra infrastructure.

Doing this properly means deciding which events genuinely warrant interruption, batching the rest into digests, giving users control over what they receive, and treating delivery as something that can fail and must be retried. It also means templating and translating content, which is invariably requested late.

Integrations introduce failure where there was none

The manual step where someone re-types data into a finance system is slow and almost never wrong, because a person notices when something looks odd. Replacing it with an API call is faster and introduces a genuinely new category of problem: partial failure.

  1. Make the call idempotent, so a retry cannot create a duplicate downstream record.
  2. Persist the outcome of every attempt, so the state is knowable after a restart.
  3. Retry transient failures with backoff, and separate them clearly from permanent ones.
  4. Build a reconciliation view that shows which records have not reached the target system.
  5. Give support staff a way to re-drive a stuck item without touching the database.

The last two are the ones teams skip and then build under pressure six weeks after launch, usually during an incident.

The exceptions are the real project

Every manual process quietly accommodates exceptions. An approver waives a document because they know the applicant. A late submission is accepted because of a phone call. A correction is made after approval because it was obviously a typo.

A portal must either encode these exceptions as rules, route them to someone authorised to make them, or refuse them outright. Refusing them outright is the option teams accidentally choose by saying nothing, and it is what produces the complaint that the new system is less flexible than the spreadsheet. Making exception handling an explicit, permissioned, audited path is usually the difference between adoption and resistance.

Operations is now a deliverable

A manual process has no uptime requirement and no stuck items, because a person is holding it. A portal needs monitoring for items that have sat in one state too long, dashboards that show throughput, administrative tooling to unstick individual records, and someone accountable when it stops. None of this appears in a feature list written from the business case, and all of it is required from day one of go-live.

Conclusion

Moving to self-service does not remove work so much as relocate it: from many people improvising daily to one system behaving predictably, plus a team that owns that behaviour. The projects that succeed are the ones that name the transfer up front - schema, identity, authorisation, state, notifications, integration failure, exceptions, and operations - and plan for it. The ones that struggle build the happy path, ship it, and then discover that the multi-stage reality of the process was where all the value and all the complexity actually lived.

Contact

Let’s connect

Have a Liferay or Backend project you’d like to talk through? Fill in the form and I’ll get back to you.

Book Calendar