What's next for AggieBites

🟦 Aggie Bites

Delivering Davis, one bite at a time.

🚀 Inspiration

As students at UC Davis, we experienced firsthand how expensive and inefficient food delivery can be for college students. Large delivery platforms often charge high service fees and commissions, which hurt both students and local restaurants.

We wanted to build a system designed specifically for a campus environment — one that prioritizes affordability, speed, and community impact. That vision led to the creation of Aggie Bites, a student-focused delivery platform built to support both local businesses and the UC Davis community.

🛠️ How We Built It

Aggie Bites is a full-stack web application designed with scalability and modularity in mind.

🔹 Frontend

Built using React
Blue and yellow theme inspired by UC Davis
Role-based dashboards:
- Customers (students)
- Restaurant partners
- Delivery agents
Real-time order tracking and clean UX flow

🔹 Backend

Built with FastAPI
RESTful API architecture
Role-based authentication and authorization
Dispatch logic for assigning delivery agents
Async Redis integration for real-time state management

🔹 Database & Infrastructure

PostgreSQL for persistent storage
Redis for caching and dispatch state
Uvicorn for ASGI server deployment
GitHub for version control and collaboration

📚 What We Learned

Building Aggie Bites taught us:

How to design scalable backend systems
Managing async workflows and state using Redis
Handling Git workflows (rebasing, resolving conflicts, collaborative pushes)
Designing role-based systems with secure authentication
Structuring a full-stack project for maintainability
The importance of clean API design and modular architecture

We also learned that engineering isn’t just about writing code — it’s about designing systems that solve real problems efficiently.

⚙️ Technical Highlights

Dispatch Optimization Concept

We explored simple optimization logic for assigning delivery agents efficiently.

If we define:

( d_i ) = distance from agent ( i ) to restaurant
( t_i ) = estimated delivery time
( s_i ) = agent availability score

We can model agent selection as minimizing:

[ \text{Score}_i = \alpha d_i + \beta t_i - \gamma s_i ]

Where:

( \alpha, \beta, \gamma ) are tunable weights
The agent with the lowest score is assigned the order

This approach allows dynamic and scalable dispatch logic.

🚧 Challenges We Faced

🔸 Git Conflicts & Rebasing

Managing collaborative workflows and resolving rebase conflicts was one of the biggest practical challenges.

🔸 Environment & Dependency Issues

Handling virtual environments, Redis setup, and async configurations required careful debugging.

🔸 Role-Based System Complexity

Designing multiple user roles (customer, restaurant, agent) with separate permissions required thoughtful architecture.

🔸 Real-Time Dispatch Logic

Ensuring consistent order assignment without race conditions required integrating async Redis carefully.

🌟 Impact

Aggie Bites aims to:

Reduce delivery costs for students
Support local Davis restaurants
Create flexible earning opportunities for student delivery agents
Build a scalable campus-first logistics platform

🔮 Future Improvements

Real-time map tracking
Smarter dispatch using predictive modeling
Order batching optimization
Mobile app version
Advanced analytics dashboard for restaurants

Aggie Bites represents more than just a delivery app — it’s a community-centered platform built to empower students and local businesses through technology.