Product and technical case study

Service order management with an auditable workflow.

This personal demonstration project is based on a hypothetical service company that needs to bring requests from emails and spreadsheets into a shared workflow. I designed and built an internal application for dispatchers, technicians, customers and administrators.

The live demo lets you explore the operational overview, roles and related status changes.

Unclear ownership and no shared view of an order’s status.

The project is based on a hypothetical service company receiving requests by email, phone and spreadsheet. Without a shared workspace, ownership is split between individuals and handovers depend on personal communication.

  • Unclear ownership: it is not clear who is responsible for handling a request.
  • Changes are hard to trace: important context remains in individual conversations.
  • No shared status: team members have different ideas of what has been completed.
  • Unreliable handovers: the next role lacks a dependable basis for its next step.

From receiving a request to closing an order.

A dispatcher takes ownership, schedules the work and assigns it to a technician. After the work is completed, it is reviewed and approved by the customer before the order is closed.

01Request receivednew order
02Dispatcher takes ownershipresponsibility
03Schedulingdate and technician
04Work completedwork log
05Reviewdispatcher
06Customer approvalclosure

Data consistency, permissions and traceable changes.

The central design challenge is keeping the workflow consistent while protecting the responsibilities of each role.

01

The state model as a domain rule

An order cannot move freely between arbitrary steps in day-to-day operations. Its lifecycle is therefore expressed through explicit states and permitted transitions that reflect each handover.

Practical outcome: the workflow is easy to follow, and process changes can be maintained in one place.

02

Authorisation by role and current state

The same order presents different tasks to a dispatcher, technician or customer at different points in its lifecycle. Laravel Policies evaluate permissions based on the user’s role and the order’s current state. The API provides the frontend with the permitted actions, which the interface uses to show available next steps. Permissions are checked again by the API when an action is performed.

Practical outcome: users are offered only the next steps they are actually allowed to take.

03

Data model and operational relationships

An order refers to a customer’s service location and the people responsible for it. Work logs are stored as separate records linked to the order, while customers and locations can be shared across multiple orders.

Practical outcome: every order has traceable context, and customer and service-location details do not need to be recorded again.

04

Backend-managed change history

A backend service handles every order change and records it in a dedicated audit table. The history is created on the backend, independently of how it is displayed in the user interface.

Practical outcome: the order’s progress can be traced without relying on emails or personal conversations.

Working interfaces for each role.

The backend controls the order lifecycle and role permissions. The frontend gives dispatchers and technicians a clear interface for day-to-day work, while customers can see the current status of their orders.

OPERATIONAL OVERVIEWOne place to see the orders

The dashboard gives dispatchers a quick view of work and statuses, so the next step does not depend on searching across several sources.

ORDER DETAILSContext for the next step

The detail view brings together the status, date, assignment and information needed for a handover without searching elsewhere.

TECHNICIAN’S WORKA record of completed work

The technician records the work directly against the order, giving the next role specific information to review.

AUDIT HISTORYChanges that can be traced

The timeline preserves the sequence of events and status changes needed for review and clear ownership handovers.

ADMINISTRATIONCustomers and service locations

Reference data is managed separately, so the workflow can point to a specific service location.

Each technology has a clear responsibility.

Working interfaceAngular

Each role works with orders through a single interface.

Domain layerLaravel API

Rules, authorisation and state transitions keep the process consistent.

Data and historyMySQL

Operational data and audit records remain traceable.

Automated testing

Backend: More than 100 PHPUnit tests cover sign-in, role permissions and order management. Integration scenarios exercise the full order lifecycle from creation through customer approval and closure, including the audit trail. Tests also check invalid input and unauthorised access.

Frontend: Vitest and Angular TestBed cover sign-in, role-based access, order operations and API data handling. Selected error and edge cases are included as well.

Demo deployment: The Laravel backend runs on Railway and the Angular frontend on Netlify.

Technical detail: endpoints, data schemas and workflow operations are described in the OpenAPI documentation .

A functional MVP to explore.

The current MVP covers the basic service order lifecycle from intake to closure, as well as user, customer and service-location management. Related operational features are listed separately as ideas for further development, not as part of the MVP shown here.

Try the workflow in the live demo

Possible next steps

  • notifications for the next roles in the workflow,
  • technician capacity planning,
  • exports and operational reporting,
  • integrations with other business systems.