Introduction
A couple of weeks ago, I built a full-stack mobile and AI-powered supply chain optimization app designed to simulate the real world. The goal of the project was to build an intelligent system that combines:

• Mobile development
• Backend engineering
• Data analytics
• Machine learning into a single production-style architecture.

The platform built with

• React Native (Expo + TypeScript)
• Zustand
• TanStack Query
• FastAPI (Backend)
• MySQL (Database)
• SQLAlchemy for ORM and database relationships
• Pandas for analytics and data processing
• Scikit-learn (Model) was designed to support advanced logistic features such as Route optimization, Warehouse analytics, Demand forecasting, Anomaly detection and Shipment delay predictions.

Why I Built This Project
One of the most interesting parts of this project has been bridging mobile engineering with AI engineering. Instead of building isolated ML notebooks, I wanted to build a system where AI was integrated directly into a real application. A system where users can interact with predictions and analytics, get real live operational insights all within the mobile app.

The backend follows a modular structure:app/
app/
├── models/
├── api/
├── schemas/
├── services/
├── analytics/
├── core/
├── db/
├── utils/
└── scripts/

Database Design
The system currently contains three major entities:
Shipments
class ShipmentCreate(BaseModel):
product_name: str
origin: str
destination: str
status: str
distance_km: float
expected_delivery_days: int
actual_delivery_days: int
warehouse_id: Optional[int] = None
driver_id: Optional[int] = None

Warehouses
class WarehouseCreate(BaseModel):
name: str
city: str

Drivers
class DriverCreate(BaseModel):
name: str
truck_number: str

These relationships allowed me to model a simplified logistics network.

Building the Analytics Layer
This was where the project started transitioning from a CRUD application into an AI-powered system.
I used Pandas to convert logistics data into analytics-ready DataFrames.
Example:
shipments_df = pd.read_sql(
"SELECT * FROM shipments",
engine
)

Shipment Analytics
Some of the analytics currently implemented include:
Shipment Status Analysis
shipments_df["status"].value_counts()

Delivery Performance
shipments_df[
"expected_delivery_days"
].mean()

Route Analysis
shipments_df.groupby(
["origin", "destination"]
).size().sort_values(ascending=False).head()

shipments_df.groupby(
["destination"]
).size().sort_values(ascending=False).head()

Product Analysis
result = (
df["product_name"]
.value_counts(normalize=True)
.mul(100)
.round(2)
).head()

These analysis were exposed through FastAPI APIs and consumed directly by the React Native app.

Seeding Large Logistics Datasets
To simulate real logistics operations, I generated synthetic shipment data using Faker and Mockaroo. This allowed me to create:

• Thousands of shipments
• Multiple drivers
• Multiple warehouses

This was important because AI models require larger datasets for meaningful analysis.

Transitioning Into AI
The most exciting part of the project was the machine learning roadmap.

Route Optimization
Identify more efficient logistics routes.

Warehouse Efficiency Scoring
Analyze warehouse performance and congestion.

Demand Forecasting
Predict future shipment volumes.

Anomaly Detection
Detect unusual shipment behaviors.

Final Thoughts
This project taught me how backend systems and AI systems interact. What started as a logistics CRUD system evolved into something much bigger. I've been able to build a project that reflects both software engineering and AI engineering workflows. Links to the project can be found here : mobile, backend.