Executive mobility platform Executive mobility, live.
App and back end for an executive chauffeur service with an armored fleet in São Paulo, Rio de Janeiro and Miami.
Where I come in
- 01
Client app
Lead developer, from the first screen to what is live
- Map, ride request, scheduling and real-time tracking.
- Payments, membership program and account area.
- Architecture, tests and store releases.
- 02
Back end
One of the three most active people on the project
- Contract and endpoints of the API the app consumes.
- Points of interest, pickup areas and the price breakdown.
- PDF receipts, Live Activity and parts of the panels.
- 03
Driver app
Focused contributions
- Ride details screen reached from the history.
- From the API contract to the model and the interface, with tests.
- Year
- Since 2025
- Role
- The client app end to end, the client API and parts of the admin panel in the back end, plus focused work on the driver app.
- Stack
- Flutter
- Dart
- BLoC
- HERE SDK
- Ably
- Laravel 12
- Filament 4
- MySQL
- Stripe
- Docker
The problem
Executive transport sells predictability: the right car, at the right time, discreetly. That needs an app that shows the ride happening live, takes bookings well in advance and follows the client’s flight, plus a back end that orchestrates rides, drivers, fleet and billing across three cities and two languages.
By the numbers
- 3cities where the app operates: São Paulo, Rio de Janeiro and Miami
- 11ride states followed in real time, from request to arrival
- 4payment methods: card with 3DS, Pix, credits and partner cards
- 30+screens in the client app, from requesting a ride to the membership program
What was built
A custom map engine on the HERE SDK
A map layer built from scratch: points of interest with pickup and drop-off areas, snapping destinations to meeting points, route calculation and animation, zoom and inertia control, and the driver pin locked to the route so it never jitters.
Real-time rides, from request to arrival
An eleven-step state machine, from searching for a driver to arrival, fed by real-time events and reflected in every screen of the app.
Booking, airports and flight tracking
Rides scheduled in advance, airport transfers that follow the flight, and Meet & Greet reception, with waiting time covered when the flight is late.
Payments and fraud prevention
Card tokenization with a 3DS challenge, Pix with real-time confirmation, prepaid credits and partner cards, with receipts and tax invoices generated as PDFs in the back end.
Membership program
Plans, credits, bonuses and member history end to end: the app screens, the sign-up page on the website and the settings in the admin panel.
Live Activity and Dynamic Island on iPhone
A live arrival time on the lock screen, computed in the back end from ride events and delivered by push, with one activity per device.
The client API in the back end
OpenAPI contract, authentication, card wallet, favorite addresses, address search, history, ride details and the price breakdown, covering what the app consumes.
An area editor on top of the map
A polygon drawing tool in the admin panel, in the spirit of Figma’s pen, to map points of interest and their pickup and drop-off areas, with expanding, subtracting and vertex merging.
Inside the map
The map is the product.
The map is where clients choose the pickup point, compare classes and watch the chauffeur arrive. I built that layer on the HERE SDK, with my own control of pins, route, camera and zoom.
- Meeting points that make sense
- At airports, hotels and buildings the destination snaps to the right pickup point, with separate pickup and drop-off areas and the walking leg when there is one.
- Pins that stay out of each other’s way
- Points of interest load per region, are cached and drawn on demand, and requests that stopped mattering are cancelled while the map moves.
- The chauffeur locked to the route
- Positions arriving in real time are projected onto the route before they become movement on screen, which removes the jittering pin and the jumps between streets.
- A camera with intent
- Zoom with its own signature so it never animates twice, inertia on the gesture, and map labels suppressed when the screen needs room to breathe.
- A route that follows the choice
- The route is recalculated and animated on every change of origin, destination or class, with the estimated arrival time per vehicle class.
In the back end
What the app shows is decided on the server.
- The API the app consumes
- An OpenAPI contract kept alongside the screens: authentication, card wallet, favorite addresses, address search, history and ride details.
- Pricing, receipts and invoices
- The breakdown of the amount shown to the client, with fares, waiting, cancellation fees and discounts, and the receipts and tax invoices as PDFs.
- An area editor in the panel
- A polygon drawing tool in the spirit of Figma’s pen, with expanding, subtracting, vertex merging and overlap prevention, used by the operations team to map locations.
- Live Activity driven by the server
- The arrival time is recomputed from ride events and sent by push, with capped retries and one activity per device.
Architecture and quality
Layers and state
Moving the app from scattered notifiers to BLoC with dependency injection and a clear split between domain, data and presentation.
A generated API client
The app consumes a client generated from the same contract as the back end, so the two sides cannot drift apart quietly.
Real time
Ride events, messages and Pix confirmation arrive over real-time channels, with reconnection and well defined waiting states.
Tests
Unit and widget tests covering the ride flow, payments and membership, running on every change.
Errors in production
Error monitoring with network and navigation breadcrumbs, which shortens the path from a report to the cause.
Continuous delivery
Automated builds and releases to the App Store and Google Play, with automatic versioning and code review along the way.
Timeline
2025
The first screens and the map
I started the app from scratch: the map foundation on the HERE SDK, the ride request flow, the chat with the chauffeur and the first version of the client API in the back end.
2026 · first half
Payments and membership
Cards with 3DS, Pix, the membership program end to end, ride details with pricing and receipts, and the app’s move to BLoC.
2026 · second half
Map, Live Activity and stores
The area editor in the panel, map performance and accuracy, Live Activity on iPhone, deep links with campaign attribution, and the store releases.
Screens
Pickup snapped to the hotel’s meeting point, with the pickup area and nearby cars. 
Scheduling with date and time, vehicle class, credits and payment method. 
Confirmed ride, with the arrival estimate and the comment and reschedule actions.
Screenshots of the app taken by me. The brand and the service belong to Vippers.
Outcome
The app is published on both stores and in use across the three cities, and the project keeps going: new features ship every delivery cycle.