Case Studies/Department Portal

UX Architecture Case Study · Government · High-stakes Systems

Department Portal — one secure architecture for complex, multi-rank workflows

A high-stakes platform shaped by defining departmental processes, mapping responsibilities and permissions, and demonstrating every workflow before it moved into implementation.

My role
Product Designer / UX Architect
Domain
Government · E-Governance
Duration
8 months, phased rollout
Platform
Web · multi-department, multi-role
5Ranks designed for
12+Modules in one shell
1Shared workflow architecture
8 moPhased rollout

Disconnected operational processes, turned into one secure digital platform

The Department Portal brings many paper-based and disconnected departmental processes into one secure, role-based web application. It was designed for high-stakes operational work, where permissions, traceability, data accuracy and clear responsibility matter as much as ease of use.

Client details are confidential, so this case study focuses on the architecture, decisions and process rather than the organisation.

My role: As Product Designer and UX Architect, I turned complex departmental processes into one coherent product architecture. I owned process definition, task flows, role-based navigation, interaction design, reusable components, stakeholder demonstrations and developer handover.

Historic processes with no shared accountability

Each department had built its own way of working over years: some on paper, some on isolated spreadsheets or standalone tools. None of it was connected and none of it was auditable. Attendance and case entries could be changed after the fact, with no trace of who made the change.

The mandate from leadership was explicit: digitise departmental processes, reduce the risk of unauthorised changes with verified, multi-factor-authenticated actions, and reduce paper dependency across the platform.

01

Manual tracking caused errors

Manual attendance and case entry led to discrepancies, payroll inaccuracies and hours spent checking records by hand.

02

No real-time visibility

Senior officers couldn’t monitor progress across locations, so leadership stayed reactive instead of proactive.

03

Weak safeguards against changes

Paper and unauthenticated digital entries could be altered with no way to trace a change to a verified person.

04

Disconnected systems

Separate tools forced manual reconciliation of information that should have moved through controlled workflows.

“Every important action must be attributable, reviewable and understandable within the officer’s role and approval chain.”The design requirement behind every decision

Understanding operational reality before designing a single screen

Each operational area had to be understood on its own terms first. Processes carried different responsibilities, historic data, forms and tools. Every discovery session followed the same discipline: document the process as it actually ran, identify the responsible roles and approval points, and catalogue the forms, registers and tools around it.

01

Process evidence

Forms, registers, task sequences, existing tools, data dependencies and recurring operational constraints.

02

Architecture evidence

Responsible roles, approval levels, permissions, shared patterns, exceptions and cross-process information needs.

  • Stakeholder workshops
  • As-is process mapping
  • Form and data review
  • Approval mapping
  • Constraint capture

Many processes, one architecture

With the current processes mapped, I converged them into one application. Each operational process became a configurable module, each rank shaped navigation and access, and every task was designed so it could be reused instead of rebuilt.

Core modules in one shell

  • Case registration
  • Case tracking
  • Attendance & payroll
  • HR & transfers
  • District analytics
  • Notifications
  • Document management
  • Duty scheduling
  • Complaints
  • Inter-department communication
  • Audit logs
  • Access control

Design principles

01

Progressive disclosure

Dense case data revealed in layers, so each rank sees what it needs first.

02

One primary action per screen

Every screen built around the single task the officer came to do.

03

One status language

The same status names and colours across every module and approval chain.

04

Breadcrumbs through approvals

Clear wayfinding through nested, multi-level approval flows.

Standardise the accountability pattern, not every departmental process

Departments had different tasks and terminology, but the same high-stakes behaviours kept repeating: create or update a record, verify identity and permission, route it for review, communicate status and keep a trace of what changed. I chose one shared, role-based workflow foundation instead of designing each department as a separate product.

01

Option avoided

Separate workflow logic for every department would have multiplied interaction patterns, training effort and inconsistency.

02

Direction selected

Shared workflow patterns with role-based configuration: approvals, escalations, forms, status and history behave predictably everywhere.

03

Trade-off managed

Interaction behaviour is standardised, while rank, permission and exception differences are kept wherever they change the task.

From operational reality to buildable workflows

I used a structured design-thinking approach. Its value was in the decisions it enabled, not the method itself.

  1. Observe the operationDocument forms, task sequences, tools, data, constraints and where accountability breaks down.
  2. Define responsibilityMap roles, permissions, approvals, exceptions and the information each rank needs to act.
  3. Create reusable flowsTurn recurring approvals, escalations, forms and status changes into consistent patterns.
  4. Demonstrate the scenarioWalk stakeholders through the full process and refine it where evidence improves usability or feasibility.
  5. Narrate behaviourExplain happy paths, alternate paths, permissions, errors and confirmations with engineering before handover.

How every component and change was signed off

Define→Demonstrate→Refine→Narrate

For every new component or process change, I explained the full scenario to stakeholders, managers and developers: the user, responsibility, rule, permission, result and impact on connected processes.

Five ranks across a strict hierarchy

On top of many operational areas sat a second layer of complexity: rank. Each role has different responsibilities and access, from senior officers reviewing overall performance to constables completing focused daily tasks.

  1. State-level officerState-wide oversight, district performance dashboards, escalations and HR decisions.
  2. District headCase review, personnel allocation, transfers and coordination across sub-divisions.
  3. Circle officerCase assignment, investigation monitoring and team attendance.
  4. Station officerCase registration, daily attendance, case updates and direct team coordination.
  5. Field staffAssigned duties, attendance, field updates and focused access to relevant actions.

A representative day for a station officer

A composite scenario built from the walkthroughs showed exactly where the day broke down, and what each step should become.

01

Attendance

Before: logged by hand in a register, every day.
After: digital attendance, synced automatically to payroll.

02

Case records

Before: handwritten notes, where one mistake caused downstream corrections.
After: a structured digital form with validation.

03

Reporting upward

Before: a physical report sent by hand, with no confirmation it arrived.
After: digital submission with a read receipt and audit log.

04

Month-end payroll

Before: registers reconciled with HR, with disputes every month.
After: payroll calculated from attendance data.

Built once, configured across many operational areas

The same underlying tasks (an approval, an escalation, an attendance capture, a document upload) repeated across departments in slightly different forms. I designed them as reusable patterns that each process could configure, while keeping behaviour and status communication consistent.

01

Foundations

Status colour roles, a legible type scale, spacing rules, responsive layout guidance and a consistent icon approach.

02

Component library

Data tables with sort, filter and bulk actions, approval workflow components, multi-level forms, status badges, dashboard cards and role-based sidebar navigation.

Multi-factor authentication and a traceable, paperless process

For sensitive actions such as edits, approvals and sign-offs, I defined the UX requirements for stronger authentication, role-based permissions, confirmation and traceable activity. Security and engineering teams owned the technical implementation.

I reviewed every paper-dependent step to find where a structured digital form, visible status and accountable approval path could replace manual movement without removing necessary controls.

  • Multi-factor authentication
  • Traceable activity
  • Data integrity
  • Paper reduction by design

Every process defined, demonstrated and refined

Prototype flows were reviewed across ranks and departmental scenarios to confirm each process had translated correctly into the shared architecture. Issues found in attendance submission and case escalation were used to refine sequence, validation and status visibility.

Each completed process was demonstrated end to end, so stakeholders could verify responsibilities, rules, exceptions and outcomes before implementation moved forward.

Reviewed with

  • Senior officers
  • Department stakeholders
  • Managers
  • Developers

Built for

Five ranks, one platform

Role-based access from state-level oversight to field duties.

A scalable foundation for secure, accountable operations

Verified post-launch analytics weren’t available for this project, so these outcomes describe the product, architecture and delivery improvements I can stand behind.

01

One shared architecture

Every departmental module uses the same product shell, navigation logic and reusable workflow foundation.

02

Role-based clarity

Officers see the actions, information and approvals that match their responsibilities and access level.

03

Reusable high-stakes patterns

Approvals, escalations, forms, status and document actions follow predictable interaction models.

04

Traceability by design

Sensitive processes include clear ownership, confirmation, history and audit requirements.

Stronger implementation alignment: process demonstrations and narrated handovers gave stakeholders and developers a shared understanding of expected behaviour before anything was built.

13 · Conclusion

High-stakes UX is about responsibility, not just screens

Designing a high-stakes system means understanding responsibility, permissions, consequences, exceptions and the information people need to make accountable decisions. The biggest lesson was the value of defining and demonstrating every process: scenario reviews exposed misunderstandings early, and narrated handovers kept architecture, design and build connected.

In a next phase, I would set up verified measures for task completion, correction rates, approval turnaround and paper reduction, to connect the architecture to real operational outcomes.