Logistics Platform · 2026
ALIGO
A logistics ecosystem connecting cargo owners, drivers and businesses through one platform — the full cargo lifecycle, from publishing to delivery, tracking and rating.
Engineering snapshot
- ~21k Lines of Code
- 54 API Endpoints
- 275 Automated Tests
- 24 Mobile Screens
- 23 Backend Modules
- 3 Client Platforms
Technologies
- Flutter
- Dart
- Material 3
- Light / Dark theme
- mapbox_maps_flutter
- geolocator
- socket_io_client
- firebase_messaging
- google_sign_in
- flutter_secure_storage
- fl_chart
- intl / l10n
- Node.js
- Express 5
- Socket.IO
- PostgreSQL
- SQLite (local)
- JWT
- bcrypt
- firebase-admin
- Telegraf
- Anthropic Claude SDK
- Mapbox Directions API
- express-rate-limit
- node:test
- Docker
- Docker Compose
- nginx
- Let's Encrypt / certbot
- PostgreSQL 16
- Render
Problem
In Uzbekistan, cargo owners and drivers still find each other through scattered channels — phone calls, Telegram groups, personal contacts.
That leaves pricing unclear, cargo status invisible, and suitable drivers hard to find, with return trips often running empty. There is no shared workflow and no reputation carried between the two sides.
Both sides need one common system.
Solution
ALIGO connects cargo owners, drivers and businesses in a single logistics ecosystem.
A cargo owner publishes a shipment — pickup, destination, cargo type, weight, price and special requirements. Drivers discover suitable cargo nearby and accept it. From there the shipment moves through a clear state machine: accepted → in transit → completed, and both sides rate each other afterwards.
On top of that: real-time tracking, automatic price calculation, deterministic driver matching, notifications, Telegram integration and an AI support chat. The mobile app, Telegram bot, Telegram Mini App and admin panel all run on the same Node.js API.
My role
I built ALIGO solo — from architecture to production.
That covered system and database design, the backend and REST API, the Socket.IO real-time layer, authentication and authorization, and the full Flutter mobile application — 24 screens and 41 reusable widgets, in three languages (~393 localization keys).
It also covered the domain logic: the cargo lifecycle, the auto-dispatch matching algorithm, the pricing engine, the notification system, the Telegram bot and Mini App, the AI support chat and the admin panel — plus Docker deployment, nginx and the PostgreSQL production setup.
Architecture
The backend is an Express 5 monolith organised into services — 23 services over 10 data models, exposed through 54 REST endpoints across 8 routers, with authentication and the real-time layer alongside them.
The data layer runs PostgreSQL in production and SQLite locally — the app switches automatically based on whether DATABASE_URL is set, so application logic stays independent of the database environment.
Clients — the Flutter app, the Telegram bot and Mini App, and the admin panel — all talk to the same API over REST and Socket.IO.
- Clients Flutter mobileTelegram bot · Mini AppAdmin panel
- Transport REST APISocket.IO
- Application Node.js · Express 5
- Domain ServicesAuthReal-time
- Data PostgreSQL — productionSQLite — local
Deterministic driver matching
When cargo is published, ALIGO matches it to drivers with a rule-based scoring system — not machine learning. Hard filters run first (vehicle fit, availability, distance limits); the remaining drivers are scored, and offers go out in rounds with TTL-based expiry, driven by an in-process scheduler.
The score combines seven factors:
- 01 Distance
- 02 Price
- 03 Driver rating
- 04 Acceptance history
- 05 Favourite route
- 06 Deadline urgency
- 07 Return-trip compatibility
The algorithm is deterministic, explainable and testable. AI is not involved in choosing drivers.
Scoped Socket.IO tracking
Live location and shipment-status updates run over a Socket.IO real-time layer. Each shipment has its own room, and a user can only join the room for a shipment where they are the cargo owner or the assigned driver — so shipment-specific data never reaches unrelated users.
Claude-powered support assistant
ALIGO includes an AI support assistant built on Claude, answering in Uzbek, Russian and English. If the AI API is unavailable, it falls back to predefined responses.
This is deliberately separate from auto-dispatch: business rules decide who hauls the cargo, AI only helps users. AI is used where it adds value, not wired into the core logic.
Engineering decisions
Why Node.js + Express, not Django
Python and Django are among my primary technologies, but ALIGO's core is real-time: continuous driver and cargo tracking, live shipment status, asynchronous notifications, and Telegram and external-API integrations.
Node.js' event-driven, async-I/O model — together with Socket.IO — was a natural fit for that workload, and it kept the integration layer simple and consistent. This is not a claim that Django can't do real-time or that Node is universally better; it is a fit decision for this product.
Principle Technology should follow the problem — not the other way around.
Challenges
- 01
One codebase, two databases
Local development uses SQLite, production uses PostgreSQL — and
COUNT(),AVG(), numeric types and date formats do not always behave the same across the two. I normalise query results in JavaScript so the rest of the app sees one consistent shape. - 02
Race conditions on acceptance
Several drivers could try to accept the same cargo at once. Acceptance is a single atomic
UPDATE … WHERE status = 'open', and both manual acceptance and auto-dispatch offers go through the same state-transition logic — so one shipment can never be accepted twice. - 03
Keeping AI out of the core
Driver matching was intentionally built as deterministic business rules rather than ML, which keeps it predictable, explainable and testable. Claude is used for the support chat instead.
- 04
The sleeping Render instance
On the free Render tier the backend can take around 50 seconds to wake. Session restoration uses retry-with-backoff, so users are not wrongly bounced to the login screen while the server spins up.
Result
ALIGO is a working end-to-end logistics system: a Flutter mobile app, a Telegram bot and Mini App, an admin panel, and a Node.js / Express API on PostgreSQL.
It covers the full workflow — publishing, discovery, acceptance, pickup, real-time tracking, delivery and rating — with automatic pricing, deterministic matching, notifications and AI-powered support.
- Publish cargo
- Discovery
- Driver accepts
- Pickup
- Real-time tracking
- Delivery
- Rating
Integrations
- Firebase Cloud Messaging
Push notifications to mobile devices.
- Telegram
Bot + Mini App — drivers can act on offers directly inside Telegram.
- Mapbox Directions API
Distance and route calculation for pricing and tracking.
- Claude API
AI support assistant inside the app, with a predefined-response fallback.
Key features
- Phone + password
- Email OTP recovery
- Google Sign-In
- Session restoration
- Shipper / Driver roles
- Profile
- Vehicle & capabilities
- Publish cargo
- Find nearby cargo
- Filter by vehicle fit
- Accept
- Pickup
- In transit
- Complete
- Rating
- Cancellation
- Category-based pricing
- Distance
- Weight
- Special equipment
- Mapbox route calculation
- Nearby drivers & cargo
- Urgent cargo
- Common routes
- Price trends
- Monthly statistics
- Matching indicators
- FCM push
- In-app notifications
- Telegram DM
- AI support chat
- Admin panel
- Analytics
- User blocking
Overview
ALIGO is a logistics ecosystem connecting cargo owners, drivers and businesses through one digital platform.
Built with a Flutter mobile application and a Node.js / Express backend, the system combines cargo management, real-time tracking, automatic pricing, deterministic driver matching, notifications, Telegram integration and an AI-powered support assistant — the full cargo lifecycle from publishing to delivery and rating.