FoodExpress: Building A Scalable Delivery System

by Alex Johnson 49 views

Embark on a journey to design and implement a robust and scalable food delivery system. This article delves into the intricacies of building FoodExpress, a hypothetical platform designed to handle a growing volume of orders while maintaining efficiency and a seamless user experience. We'll explore the architecture, key features, and scalability considerations involved in creating a production-ready system. This exploration includes everything from crafting an effective RFC document to implementing API endpoints and integrating cutting-edge AI for natural language menu queries. Get ready to dive deep into the world of backend development and learn how to construct a system capable of handling the demands of a thriving food delivery business.

Overview: The FoodExpress Challenge

The challenge is to create a food delivery system demonstrating architectural thinking, clean code principles, and AI integration. The goal is to design a system capable of scaling from an MVP handling 1,000 orders per day to a robust platform supporting 50,000 orders per day. This involves careful consideration of system architecture, technology stack, and scalability strategies. We’ll walk through how to achieve this, making sure your system is ready for anything.

Key Objectives

  • MVP to Production Architecture: Design a system that can evolve from a minimal viable product (MVP) to a production-ready architecture.
  • Hexagonal/Clean Architecture: Implement the system following hexagonal or clean architecture principles to ensure maintainability and testability.
  • AI Integration: Integrate with AI services like Ollama for natural language menu queries, enhancing user experience.
  • Scalability: Chart a clear path for scaling the system from 1,000 to 50,000 orders per day.

This challenge is structured around specific time constraints to simulate real-world development scenarios. You will learn to plan effectively and execute efficiently.

Business Requirements: The Foundation of FoodExpress

Pricing Rules: Calculating Delivery Fees

Accurate and transparent pricing is critical for any food delivery service. FoodExpress uses a combination of fixed fees, surcharges, and discounts to calculate the final delivery cost.

  • Base Delivery Fee: The base fee varies based on the delivery zone:
    • Zone 1 (Less than 3km): $3
    • Zone 2 (3-7km): $5
    • Zone 3 (Greater than 7km): $8
  • Peak Hour Surcharge: A surcharge of 30% is applied during peak hours (12-2pm and 7-9pm) to account for increased demand and driver availability.
  • Loyalty Discount: Orders exceeding $50 receive a 15% discount on the delivery fee, encouraging larger orders.

Understanding these pricing rules is crucial for building the backend logic that accurately calculates order totals.

Core Features: Functionality at the Heart of FoodExpress

FoodExpress must provide essential features for users to easily order food. These include restaurant and dish search, order creation, and AI-powered menu exploration.

  1. Search Restaurants and Dishes:
    • Allow users to search for restaurants and dishes by location, cuisine type, and dietary preferences (e.g., vegetarian, vegan).
  2. Create Orders:
    • Enable users to create orders by providing customer information (name, email, phone), delivery details (address, zone), and selecting items from the menu.
  3. Process Natural Language Queries:
    • Integrate with Ollama to process natural language queries for menu exploration. This allows users to ask questions like, "What's good for a vegan dinner party?" and receive relevant recommendations.

These core features define the primary user interactions with the system and must be implemented efficiently and effectively.

Scalability Challenge: Planning for Growth

A key aspect of the FoodExpress challenge is designing for scalability. The system should be able to handle a significant increase in order volume without performance degradation. This requires a phased approach:

  • Phase 1: MVP (In-Memory, Single Server)
    • Start with an in-memory database and a single server architecture for rapid development and deployment.
  • Phase 2: Production (Database, Connection Pooling)
    • Migrate to a persistent database (e.g., PostgreSQL, MySQL) and implement connection pooling to handle increased load.
  • Phase 3: Scale (Load Balancing, Caching, Real-Time Tracking)
    • Introduce load balancing to distribute traffic across multiple servers. Implement caching mechanisms to reduce database load. Add real-time order tracking to enhance user experience.
  • Phase 4: Microservices (Restaurant Service, Order Service, Delivery Service)
    • Break the application into microservices (e.g., restaurant service, order service, delivery service) to improve maintainability and scalability.

Documenting the evolution path is crucial for guiding future development and ensuring the system can adapt to changing demands.

Deliverables: The Building Blocks of FoodExpress

To successfully complete the FoodExpress challenge, you must deliver three key components:

1. RFC (Request for Comments) Document: The Blueprint

The RFC document is a critical deliverable that outlines the design and architecture of the FoodExpress system. It should cover the following areas:

  • Executive Summary and Problem Statement:
    • Provide a high-level overview of the system and the problem it aims to solve. This section should clearly define the scope and objectives of the project.
  • System Architecture Approach (Hexagonal Pattern):
    • Describe the system architecture using the hexagonal architecture pattern. Explain how this pattern promotes separation of concerns and testability.
  • Path to Scale from 1K to 50K Orders/Day:
    • Detail the steps required to scale the system, including database choices, caching strategies, and load balancing techniques.
  • Technology Stack Justification:
    • Justify the chosen technology stack, explaining why specific technologies were selected based on their suitability for the project requirements.
  • Implementation Strategy:
    • Outline the implementation strategy, including the order in which features will be developed and the approach to testing and deployment.

The RFC document serves as a blueprint for the entire project, ensuring that all stakeholders have a clear understanding of the system's design and implementation.

2. Three Working API Endpoints: The Functionality

Implement three API endpoints that provide the core functionality of the FoodExpress system:

Endpoint 1: Search Restaurants & Dishes

This endpoint allows users to search for restaurants and dishes based on various criteria.

  • Request:
    GET /api/restaurants/search?location=Downtown&cuisine=Italian&dietary=vegetarian&max_distance=5
  • Response:
    {
  "restaurants": [
    {
      "id": "rest-1",
      "name": "Bella Italia",
      "location": "Downtown",
      "distance_km": 2.5,
      "cuisine": "Italian",
      "rating": 4.5,
      "delivery_time_minutes": 30,
      "featured_dishes": [
        {
          "id": "dish-1",
          "name": "Margherita Pizza",
          "price": 15.99,
          "dietary_tags": ["vegetarian"]
        },
        {
          "id": "dish-2",
          "name": "Pasta Primavera",
          "price": 18.50,
          "dietary_tags": ["vegetarian", "vegan_option"]
        }
      ]
    }
  ]
}

Endpoint 2: Create Order

This endpoint allows users to create new orders.

  • Request:
    POST /api/orders
Content-Type: application/json

{
  "restaurant_id": "rest-1",
  "customer_name": "Maria Garcia",
  "customer_email": "maria@example.com",
  "customer_phone": "+1234567890",
  "delivery_address": "123 Main St, Downtown",
  "delivery_zone": 1,
  "items": [
    {
      "dish_id": "dish-1",
      "quantity": 2
    },
    {
      "dish_id": "dish-2",
      "quantity": 1
    }
  ],
  "order_time": "2025-11-11T13:00:00Z"
}
  • Response:
    {
  "order_id": "order-xyz789",
  "restaurant_id": "rest-1",
  "customer_name": "Maria Garcia",
  "items_total": 50.48,
  "delivery_fee": 3.90,
  "total_price": 54.38,
  "estimated_delivery_time": "2025-11-11T13:45:00Z",
  "status": "confirmed",
  "breakdown": {
    "subtotal": 50.48,
    "base_delivery_fee": 3.00,
    "peak_surcharge": 0.90,
    "loyalty_discount": 0.00
  }
}

Endpoint 3: AI-Powered Menu Query

This endpoint integrates with Ollama to process natural language queries.

  • Request:
    POST /api/ai/query
Content-Type: application/json

{
  "query": "I'm craving something spicy and healthy for lunch under $20"
}
  • Response:
    {
  "answer": "Perfect! I found a great option for you: the Spicy Thai Curry Bowl from Bangkok Street. It's packed with fresh vegetables, brown rice, and your choice of protein. At $16.99, it fits your budget and it's both spicy and nutritious. They can deliver in about 25 minutes!",
  "recommendations": [
    {
      "restaurant_id": "rest-5",
      "restaurant_name": "Bangkok Street",
      "dish_id": "dish-23",
      "dish_name": "Spicy Thai Curry Bowl",
      "price": 16.99,
      "dietary_tags": ["healthy", "gluten_free_option", "spicy"],
      "distance_km": 3.2,
      "delivery_time": 25
    }
  ],
  "parsed_query": {
    "preferences": ["spicy", "healthy"],
    "meal_time": "lunch",
    "max_price": 20,
    "dietary_restrictions": []
  }
}

This endpoint demonstrates the power of AI in enhancing user experience by providing natural and intuitive menu exploration.

3. README.md: The Guide

The README.md file is the documentation hub for the FoodExpress system. It should include:

  • Setup Instructions:
    • Detailed instructions on setting up the development environment, including dependencies, Ollama installation, and server startup.
  • How to Test Each Endpoint:
    • Clear steps on how to test each API endpoint, including example requests and expected responses.
  • Architecture Summary:
    • A concise summary of the system architecture, highlighting key components and their interactions.
  • RFC Document:
    • Embed or link the RFC document to provide a comprehensive overview of the system's design and implementation strategy.

A well-written README.md is crucial for ensuring that others can easily understand, set up, and use the FoodExpress system.

Evaluation Criteria: Measuring Success

The FoodExpress challenge is evaluated based on several key criteria:

Architecture (40%): The Foundation

  • Hexagonal Pattern Correctly Implemented:
    • Evaluate whether the hexagonal architecture pattern is correctly applied, ensuring separation of concerns and testability.
  • Clear Separation Between Business Logic and Infrastructure:
    • Assess the separation between business logic and infrastructure code, making the system maintainable and adaptable.
  • Easy to Swap Implementations:
    • Determine if implementations can be easily swapped (e.g., in-memory to database), demonstrating flexibility and adaptability.
  • Documented and Realistic Path to Scale:
    • Evaluate the documented path to scale, ensuring it is realistic and addresses key scalability challenges.

Implementation (40%): The Execution

  • All 3 Endpoints Functional:
    • Verify that all three API endpoints are fully functional and meet the specified requirements.
  • Business Logic Accuracy:
    • Assess the accuracy of business logic, particularly pricing calculations (zones, peak hours, discounts).
  • Code Quality and Organization:
    • Evaluate the quality and organization of the code, ensuring it is clean, readable, and maintainable.
  • Proper Error Handling:
    • Check for proper error handling, ensuring that the system gracefully handles unexpected situations.

AI Integration (15%): The Innovation

  • Ollama Successfully Parses Natural Language Queries:
    • Verify that Ollama can successfully parse natural language food queries.
  • Natural, Conversational Responses:
    • Assess the naturalness and conversational quality of the responses generated by the AI.
  • Returns Human-Friendly Answer and Structured Data:
    • Ensure that the AI returns both human-friendly answers and structured data for easy consumption.
  • Handles Ambiguous or Creative Queries Gracefully:
    • Evaluate how the AI handles ambiguous or creative queries, demonstrating its robustness and adaptability.

Documentation (5%): The Clarity

  • RFC Completeness and Clarity:
    • Assess the completeness and clarity of the RFC document, ensuring it provides a comprehensive overview of the system.
  • README with Clear Setup Steps:
    • Evaluate the README.md file, ensuring it provides clear and concise setup instructions.

Technical Requirements: The Toolkit

The FoodExpress challenge has specific technical requirements to ensure a consistent and effective implementation.

  • Architecture:
    • Hexagonal/Ports & Adapters pattern: This architecture promotes separation of concerns and testability.
  • AI:
    • Ollama integration (llama3.2:3b or similar): Ollama provides a powerful platform for running large language models locally.
  • Storage:
    • Start with in-memory (MVP requirement): An in-memory database is suitable for the initial MVP phase.
  • Language:
    • Your choice (Python, Java, JavaScript/TypeScript recommended): These languages offer robust frameworks and libraries for backend development.

Ollama Setup: Getting Started with AI

To integrate with Ollama, follow these steps:

# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Pull model
ollama pull llama3.2:3b

# Start server
ollama serve

This setup ensures that Ollama is running and ready to process natural language queries.

Submission: Delivering Your Solution

To submit your solution for the FoodExpress challenge, follow these steps:

  1. Fork this Repository:
    • Create a fork of the FoodExpress challenge repository on your GitHub account.
  2. Create a New Branch:
    • Create a new branch for your solution to keep your work organized and isolated.
  3. Start with the RFC Document (45 Minutes):
    • Begin by creating the RFC document, outlining your design and implementation strategy.
  4. Implement the Three Endpoints (2h 15min):
    • Implement the three API endpoints, ensuring they meet the specified requirements.
  5. Submit a Pull Request:
    • Submit a pull request to the original repository, showcasing your solution.

Sample Data Structure: Guidance for Implementation

Here's a suggested data structure for restaurants to guide your implementation:

{
  "restaurants": [
    {
      "id": "rest-1",
      "name": "Bella Italia",
      "cuisine": "Italian",
      "location": "Downtown",
      "coordinates": {"lat": 40.7128, "lon": -74.0060},
      "rating": 4.5,
      "menu": [
        {
          "id": "dish-1",
          "name": "Margherita Pizza",
          "price": 15.99,
          "category": "Main",
          "dietary_tags": ["vegetarian"]
        }
      ]
    }
  ]
}

This structure provides a starting point for organizing restaurant data and menu items.

Conclusion: Mastering Scalable Systems

The FoodExpress challenge provides a fantastic opportunity to learn about building scalable food delivery systems. By focusing on hexagonal architecture, AI integration, and a clear path to scale, you can create a robust and efficient platform. Remember, the key to success lies in a well-documented design, clean implementation, and a forward-thinking approach to scalability. This article has provided a comprehensive guide to tackling the FoodExpress challenge, covering everything from business requirements to technical implementation and evaluation criteria. Embrace the challenge, apply these principles, and build a food delivery system that can handle the demands of a growing business.

For more information on backend architecture and system design, check out resources like Martin Fowler's website. This external resource can provide further insights into best practices and architectural patterns.