Fly Post: An MVP of a crew-courier air delivery service in ~5 weeks

A private client was launching a service for piggyback delivery of documents and small parcels to other cities and countries. Deliveries are made by crew members — flight attendants and pilots who are flying that route anyway. They pick up a shipment at the departure airport, hand it over at the destination and get paid for the delivery.

For the sender it is faster than courier services, for the crew it is extra income. The service is closed: access to it is granted separately.

Before the service, such deliveries were arranged by hand, through acquaintances and chats. The sender had to find a crew member on the right flight, agree on the price and the meeting, and check where the parcel was in the chat. Neither side had any guarantees: it was unclear who would pick up the shipment and when, and how the delivery would be paid. The service was meant to replace all of this with one process and clear statuses. The project started from scratch.

The service has two roles: the sender creates a parcel, a courier from the crew takes it on their flight.

The team was three people, two of them frontend developers, on a tight deadline. So the stack was chosen to keep the whole team on one language and let it start fast. NestJS on TypeScript gave shared contract types on the frontend and the backend, with no second language to learn. The team already knew Vue 3 with Vite, Pinia and Tailwind, and the ready-made daisyUI components sped up the layout work. PostgreSQL is a reliable relational database for orders and users. Docker on a VPS with GitLab CI gives low-cost infrastructure with automatic rollouts.

• CLIENTSPA

  Vue 3 on Vite, Pinia, Vue Router, Tailwind and daisyUI. Localization is laid in with vue-i18n, ru/en.

• APIREST in NestJS

  The contract is described in Swagger, the sender and courier roles are checked by guards.

• DATAPostgreSQL

  The main database with backups.

• INFRADocker on a VPS

  The frontend, NestJS and PostgreSQL run in containers, GitLab CI builds the images and rolls them out to the server.

The UI kit in Figma and on the frontend set one interface language. Screens were built from ready-made components, so new pages came faster and the interface stayed consistent without a separate design review. For the client this means cheaper changes and faster delivery of new features.

Points on the map stay readable even when there are many of them: custom SVG markers, clusters, zoom and geolocation on Leaflet, and address search with suggestions through Nominatim from OpenStreetMap. Users find the right place faster, and the business does not pay for commercial map APIs.

The order's path is shown step by step in a nested collapsible status timeline. Forms have masks and validation, the confirmation code is entered in 4 cells with a resend timer.

On the phone the navigation moves to a bottom tab bar, the shipments table scrolls sideways with a pinned actions column, the details panel and the map open full screen.

Two more integrations are planned in the architecture for the next stages: a flight schedule API, so the courier picks a flight from a list instead of typing it in, and a payment service for courier payouts. They were not connected in the MVP, and the architecture is designed to add them.

The service stores the personal data of senders and couriers: full names, phone numbers, addresses and flight details. A leak of such data undermines trust in the service and breaks the personal data law (152-FZ), so protection was built in from day one. Sensitive fields are encrypted in the application with AES-256-GCM before they are written to the database: even if someone gets access to the database or a backup, the data stays unreadable, and GCM prevents it from being tampered with unnoticed. The connection goes over HTTPS only, the database is backed up regularly, sign-in uses a one-time code through a Telegram bot, and access is split between the sender and courier roles at the API level.

Before development started, I set the project up so three developers could work on one frontend in parallel from the first week: the folder structure is described in the README, ESLint checks the code style, and all code goes through cross-review.

Tests are part of the process: unit tests for the backend and component snapshot tests on Vitest and @vue/test-utils for the frontend. Writing them was handed to AI agents to save the team's time.

I automated code delivery in GitLab CI: the pipeline builds the Docker images and rolls them out to the VPS.

1. build Docker images
2. deploy VPS

I kept the process light, sized to the team and the deadline: tasks in git issues, direct contact with the client, no sprints.