Search for a command to run...
Extending an on-demand delivery platform to support fixed vehicles, long-running assignments, and operational oversight
No comments yet. Be the first to comment.
Detailed breakdowns of real software engineering and AI projects, from problem definition and technical decisions to implementation, trade-offs, and lessons learned.
Building the frontend experiences and integrations behind recruitment, evaluation, offers, and pre-boarding
Researching and implementing a Microsoft identity integration for employee synchronization
The Engineers Don't Start With Code. They Start With the Problem.
Building the frontend experiences and integrations behind recruitment, evaluation, offers, and pre-boarding
It Was Just a Checkbox. Until It Wasn't.
Disclosure: This case study is anonymized. The client’s identity, product branding, source code, production screenshots, internal architecture, customer information, commercial terms, and performance metrics have been excluded.
Industry: Logistics and delivery
Project type: Fleet-management and recurring-order module
My contribution: Frontend development and API integration
Team:
Shebaan Kalim - UI/UX Designer
Mohammad Maheer - Backend Lead
Abdul Rahman - Backend Developer
An on-demand logistics platform works well when every delivery is an independent event.
A company enters the pickup and destination details, requests a vehicle, receives a driver assignment, and completes the delivery. The same model used by ride-hailing applications can make occasional logistics bookings significantly easier.
The model becomes less suitable when a business needs the same type of delivery repeatedly.
Some customers required vehicles for recurring routes over several weeks or months. Using the existing process meant creating another booking for every delivery, entering similar information again, coordinating with newly assigned drivers, and monitoring each request independently.
The underlying problem was not that the platform lacked a booking form. It was that a system designed around short-lived transactions now needed to support a long-running operational relationship.
Our team developed a fixed-vehicle-order module to address that difference.
My responsibility focused on implementing the frontend experience and integrating it with the backend services supporting quotations, recurring orders, driver assignments, attendance records, invoices, and operational reporting.
The platform’s original order model was suitable for variable or occasional delivery requirements.
Each request could be treated as an independent transaction:
A customer submitted delivery information.
A driver was assigned.
The delivery was completed.
The order was closed.
That lifecycle was understandable because the order had a clear beginning and end.
Recurring delivery operations behaved differently.
The customer was not purchasing one isolated journey. They were arranging an ongoing service involving repeated schedules, a vehicle and driver relationship, attendance monitoring, possible driver replacements, billing periods, and operational reports.
Trying to represent that service as dozens of unrelated orders introduced avoidable work.
| One-off delivery model | Recurring delivery requirement |
|---|---|
| A new request for each journey | One arrangement covering repeated journeys |
| Driver assigned per request | Driver associated with the service period |
| Order ends after delivery | Operational state continues over time |
| Individual payment or invoice event | Period-based billing and reporting |
| Limited history required | Attendance and performance history required |
| Changes apply to one delivery | Changes may affect future scheduled activity |
The existing model was not defective. It was designed for a different usage pattern.
The engineering challenge was extending the platform without forcing a long-running service into a short-lived transaction model.
I worked on the frontend implementation and service integration for the new module.
My contribution included:
Building the screens and workflows used to create and manage recurring vehicle orders.
Translating approved product designs into responsive frontend interfaces.
Integrating quotation, order, driver, attendance, invoice, and reporting services.
Mapping backend records into understandable operational views.
Handling loading, empty, successful, and recoverable error states.
Supporting the transition between quotation, approval, activation, and ongoing management.
Coordinating API requirements and edge cases with the backend team.
Working with the product designer to align interface behaviour with operational constraints.
Keeping the new recurring-order experience consistent with the existing platform.
I did not design or build the entire logistics platform independently. The backend services and domain rules were collaborative work owned by the relevant team members. My role centred on the customer-facing module and the integration boundary between operational services and the interface.
The most important architectural shift was recognising that a fixed-vehicle order could not be treated like a conventional form submission.
A user might begin by preparing a quotation, wait for it to move through an approval process, receive a driver assignment, monitor activity over a service period, request a replacement, and later review invoices or reports.
The record remained active while its operational state changed.
A representative lifecycle looked like this:
A company defines its recurring delivery requirements.
A quotation is created from the required locations, schedule, duration, and service details.
The quotation moves through review or approval.
A vehicle and driver are associated with the active service.
Attendance and operational activity are recorded over time.
Exceptions, such as a driver-change request, are handled without recreating the entire order.
Billing and reporting records become available for the relevant period.
The service is completed, renewed, changed, or closed.
The frontend had to make the current state understandable while presenting only the actions appropriate at that point.
A quotation awaiting approval should not expose the same controls as an active order. An active order with an assigned driver should behave differently from one awaiting assignment. A completed billing period should remain inspectable without appearing editable.
This is where operational software becomes more difficult than it first appears: the interface must represent not only data, but the rules governing what can happen next.
Backend systems often represent logistics operations as related records: quotations, orders, vehicles, drivers, schedules, attendance entries, invoices, and reports.
Customers do not think in database entities.
They think in questions:
Has the arrangement been approved?
Which driver is assigned?
Did the driver check in today?
Where was the check-in recorded?
Is a replacement request pending?
Which billing period does this invoice cover?
What activity occurred during the month?
The frontend needed to translate related service responses into views that answered those questions.
That required deciding:
Which information belonged on the order summary.
Which records needed dedicated detail views.
Which status should be most prominent.
Which actions were currently available.
How related historical information should be grouped.
What the interface should show when information had not yet been created.
How to distinguish a genuine empty state from a failed request.
These decisions affected more than presentation. They determined whether users could understand the operational condition of a recurring order without asking the support team to interpret the system for them.
The module included several connected capabilities:
Businesses needed to describe a recurring service without recreating the same information for every delivery.
The quotation flow gathered the operational details required to begin that arrangement and presented its current state as it moved through the process.
Once the service became active, the interface needed to show the assigned driver as part of the ongoing order rather than as a temporary detail attached to one journey.
A replacement request introduced an exception to the normal lifecycle.
The frontend needed to represent the current driver, the pending change, and the eventual outcome without making the order appear to have two active assignments simultaneously.
Operational monitoring required more than displaying the assigned driver’s name.
Attendance records needed to be associated with the correct order, date, and activity while remaining easy to review over a service period.
Billing information had to remain connected to the recurring arrangement while reflecting individual billing periods and payment states.
Historical activity needed to be presented in a form that supported operational review rather than forcing users to inspect every underlying event separately.
Each feature had its own interface requirements, but users experienced them as parts of one service. Shared status patterns, navigation behaviour, and data presentation helped prevent the module from feeling like several unrelated tools placed beside one another.
In a simple interface, the browser may be able to treat recently entered information as the current truth.
That assumption is unsafe in an operational platform.
A driver assignment may be changed by an administrator. A quotation may be approved by another user. Attendance may be added after the customer first opens the page. An invoice can move from unpaid to paid without the current screen initiating the change.
The frontend therefore had to treat backend data as the authority for operational state.
This created several implementation considerations:
Refreshing information after state-changing actions.
Avoiding stale controls after a status changed.
Preventing duplicate submissions while a request was processing.
Showing users that an operation had succeeded before reloading dependent information.
Preserving useful interface context during updates.
Handling cases where a record changed between the user opening it and attempting an action.
The difficult balance was keeping the interface responsive without pretending that local browser state represented the entire operation.
Recurring logistics involves exceptions.
Drivers can become unavailable. Schedules may need adjustment. A quotation may require revision. Attendance may be missing. A billing record may not yet exist.
These conditions should not be treated as surprising technical failures.
A useful operational interface needs to distinguish between:
A system error.
A pending business process.
Information that has not yet been created.
An action that is unavailable in the current state.
An exception that requires a specific follow-up step.
For example, “No driver assigned yet” communicates a different situation from “Driver information could not be loaded.” One is an operational state; the other is a technical failure.
Making that distinction consistently helped the interface communicate what the system knew, what was still pending, and whether the user needed to act.
The project delivered a new frontend module that allowed the platform to represent recurring logistics arrangements separately from individual delivery bookings.
The completed experience supported the customer-facing management of:
Recurring service quotations.
Fixed vehicle and driver arrangements.
Driver-change requests.
Attendance and check-in records.
Period-based invoices and payment states.
Operational reporting.
From an engineering perspective, the implementation produced several qualitative outcomes.
Repeated delivery requirements could be represented as one longer-lived arrangement rather than a sequence of disconnected requests.
Related information about the order, driver, attendance, changes, invoices, and reports could be accessed within one connected module.
The frontend could represent quotations, assignments, pending changes, active service, and completed records through shared status and interaction patterns.
The flow was designed to avoid requiring customers to recreate the complete service arrangement for every recurring delivery.
Separating recurring orders from variable bookings gave the product a clearer structure for future features related to scheduling, monitoring, billing, and service management.
These are qualitative product and implementation outcomes. This case study does not claim measured reductions in cost, booking time, delivery delays, support workload, or customer churn because supporting analytics and publication permission are not available.
A one-off order and a recurring service may involve similar vehicles and routes, but their software lifecycles are fundamentally different.
Most complexity comes from deciding which actions are valid, who can perform them, and how one state becomes another.
“No records yet,” “waiting for assignment,” and “request failed” may all produce an empty panel, but they require different explanations and actions.
When several users and services can modify an operation, the browser cannot safely behave as the sole source of truth.
Quotations, drivers, attendance, invoices, and reports can be implemented separately. Customers still need to understand them as one operational service.
Reusable components help, but the more important abstraction is a clear representation of the underlying business lifecycle.
This project was not simply an expansion of an existing delivery form.
It required the platform to support a different kind of relationship with its customers: one that continued across schedules, driver assignments, attendance records, exceptions, and billing periods.
My contribution was to translate that operational model into a connected frontend experience and integrate it with the backend services responsible for each stage.
The central lesson was that recurring operations cannot be managed reliably as a pile of repeated transactions. They need a product model and an interface designed around continuity.
What I demonstrated
Frontend development · API integration · Operational workflows · State modelling · Fleet-management interfaces · Error and empty-state design · Cross-functional collaboration
All accompanying diagrams and illustrations must be labelled representative or conceptual. They must not be presented as production screenshots, exact architecture diagrams, measured analytics, or reproductions of the client’s proprietary workflows.
