Guide Mobility

How to build a taxi and airport-transfer app

Driver app and dispatcher screens, a real-time architecture, and the booking edge cases that cost the most.

Short answer

A taxi or airport-transfer platform is three products on one real-time backend: a driver app, a dispatcher portal and an API that takes bookings from your own channels and from partners such as Booking.com. The map is the easy part. The real work is the booking lifecycle (amendments, flight delays, cancellations, no-shows and paying drivers correctly), so design for change from day one.

I was a core engineer on Mobio, a taxi and airport-transfer dispatch platform from the Netherlands with live driver apps on iOS and Android and rides arriving from Booking.com. I led its mobile team of four developers and made 600+ commits across the driver app, the dispatcher portal and the API.

This guide is what I’d tell a founder or CTO starting a similar product: which screens to build, how to structure the backend, and which edge cases to plan for before they reach production.

The three products you’re building

Most of the effort goes into software that passengers never see.

ProductUsed byMust do
Driver app (iOS and Android)Professional driversGo online, receive and plan rides, update ride status, report no-shows, chat with dispatch, see earnings and payouts.
Dispatcher portal (web)Taxi companies, dispatchers and adminsWatch every ride live, assign and reassign drivers, handle changes, manage drivers and vehicles, run invoices and payouts.
API and integrationsYour apps, booking partners, payment, SMS and email providersTake in bookings, apply amendments and cancellations, price rides, push real-time events and keep an audit trail.

A passenger app is optional. In B2B airport transfers most rides arrive through partners, so passengers never install anything. A consumer taxi service needs one, and it is a fourth product with its own booking, payment and live-tracking screens.

Driver app screens

Drivers use the app in a car mount, often in a hurry and often with weak signal. Every screen should answer one question at a glance.

  1. Sign-up and documents. Licence, vehicle details, insurance and permits, each with an expiry date and a review status. Drivers can’t take rides until their documents are approved.
  2. Availability. One clear online/offline switch.
  3. Assigned rides and ride planning. Upcoming rides in time order, so drivers can plan airport runs a day or a week ahead.
  4. Ride detail. Everything needed at pickup: time, address or terminal, flight number and status, passenger name and count, luggage and notes.
  5. Status flow. One large button per step: accepted, on the way, arrived, passenger on board, completed.
  6. No-show report. A timestamped, located record that the driver waited, so disputes can be settled fairly.
  7. Chat with dispatch. Drivers and dispatchers coordinate without sharing personal phone numbers.
  8. History and earnings. Paginated ride history, earnings per ride and payout status.
  9. Notifications. New assignments, changed pickup times and cancellations, each opening the right ride.

UX rules that matter more than visual polish

  • Make changes loud. When a booking changes, show what changed (old time → new time) and ask the driver to confirm they’ve seen it.
  • Keep the next ride glanceable. The next pickup and its time should be readable in a second.
  • Assume bad signal. Airports mean car parks and basements. Queue status updates and retry them, and never lose a “passenger on board”.
  • Don’t make drivers type. Big buttons and pre-filled reasons beat text fields.

Dispatcher portal screens

Dispatchers are power users. They want density, search and speed, not onboarding.

  • Live board. Today’s rides by status, with unassigned and at-risk rides on top, such as a flight that has landed with no driver assigned.
  • Ride detail with history. Every amendment, status change and reassignment, with who made it and when.
  • Assign and reassign. Pick a driver with their availability and current rides in view.
  • Drivers and vehicles. Documents, approvals and expiry alerts.
  • Global search. Find any ride by booking reference, passenger, flight or driver. Dispatchers live in search.
  • Finance. Commission rules, PDF invoices, payout approvals and Excel export for accounting.

An architecture that holds up

This is the shape we built Mobio on: a React Native (Expo) driver app, a React and TypeScript dispatcher portal, and a Node.js / Express API with MariaDB, Redis and Socket.IO. The same shape works with a Flutter driver app, which I’d build with Clean Architecture and BLoC for state management, so ride status, offline updates and real-time events are each handled and tested in isolation.

  1. Booking sources. Partner APIs such as Booking.com, your own website or app, and manual entry by dispatchers, all converted into one internal booking model.
  2. Core API. The single source of truth for bookings, rides, prices, assignments and payouts.
  3. Relational database. Bookings, drivers and money are full of relationships, and money needs transactions.
  4. Real-time layer. Socket.IO pushes ride events to the driver app and the portal; Redis lets several API instances share those events.
  5. Push notifications. Reach drivers when the app is in the background; sockets only help while it is open.
  6. Services. Payments (Stripe), SMS (Twilio), email (SendGrid) and file storage (S3) for documents and invoices.
  7. Containers. Docker images, so every environment runs the same build.

Design decisions to make early

  • Bookings are versions, not overwrites. Partners send changes to bookings you already hold. Keep each version, compare them, and tell the assigned driver exactly what changed.
  • Separate the booking from the ride. The booking is what the customer bought; the ride is the job a driver does. Reassigning a driver should never touch the booking.
  • Store times in UTC with a time zone. Flights land in local time and partners send times in different formats. Save UTC plus the pickup’s time zone, and display local time.
  • Make status updates idempotent. A driver app that retries “arrived” after a timeout must not create two events.
  • Keep an audit trail. Log every status change and amendment with time, user and location. It settles disputes and drives payouts.

Edge cases that cost the most

None of these show up in a demo. All of them show up in the first weeks of real rides.

  1. Amendments after assignment. The pickup time or address changes after a driver has accepted. Show the difference, notify the driver, require a confirmation, and alert dispatch if nobody confirms.
  2. Flight delays and early arrivals. Keep the flight number on the booking, move the pickup time with the flight, notify the driver, and decide your waiting-time rules for delayed flights before launch.
  3. Cancellations. Before assignment, after assignment and after the driver has set off are three different cases, with different fees and different driver pay.
  4. Additional bookings and edits. A return trip, an extra stop or a child seat added later. Recalculate the price and make sure the driver sees the change.
  5. Quoted fare vs final price. Waiting time, extra stops and tolls change the price after the ride. Store both prices with the reason, and send the final price back to the booking partner where required.
  6. No-shows. Define how long a driver must wait, capture proof in the app, and tell the partner.
  7. Commissions and payouts. Rules differ per company and sometimes per driver. Generate invoices, pay out to IBAN, and put an approval step before money moves.
  8. Store review for location. If you track drivers in the background, Google Play requires a background-location declaration and Apple requires a clear reason for “Always” access. Design the permission flow and its explanation screens from the start.

A sensible build order

  1. Booking model and dispatcher portal. Real rides can run with manual assignment from day one.
  2. Driver app core. Assigned rides, ride detail, status flow and push notifications.
  3. Real-time events and change alerts. Sockets plus “what changed” notifications.
  4. Partner integrations. New bookings first, then amendments, cancellations and price updates.
  5. Finance. Commissions, invoices and payouts.
  6. Passenger app. Only if you sell directly to riders.

FAQ

What features does a taxi driver app need?

Document upload and approval, an online/offline switch, assigned rides and ride planning, a ride detail screen with pickup and flight information, a one-tap status flow, no-show reports, chat with dispatch, ride history and payouts, and push notifications for every change.

How do airport-transfer apps handle flight delays?

They store the flight number with the booking, follow the flight’s status, move the pickup time when the flight is delayed or lands early, and notify the assigned driver of the new time.

What does a Booking.com transfer integration involve?

Receiving new bookings is the easy part. Most of the work is applying amendments, additional bookings, cancellations and price updates to bookings you already hold, and keeping the assigned driver in sync.

Should I build a taxi app with Flutter or React Native?

Either can ship a reliable driver app. Mobio’s driver app, for example, was built with React Native (Expo). Choose based on your team’s skills. The bigger risks are background-location rules, push-notification reliability and offline-safe status updates. If you choose Flutter, use Clean Architecture with BLoC for state management so ride status and real-time events stay predictable and testable.

What tech stack does a taxi dispatch platform need?

A mobile driver app, a web dispatcher portal, an API with a relational database, a real-time layer such as Socket.IO with Redis, push notifications, and integrations for payments, SMS and email.