Food Order Delivery App Development

Companies building multi-restaurant food delivery marketplaces, direct-to-consumer restaurant ordering platforms, and last-mile logistics networks need engineering teams who understand both the consumer-facing order lifecycle and the operational data infrastructure underneath it. Scrums.com provides dedicated software engineering teams for food order delivery platform development, deploying production-ready systems with real-time driver tracking, idempotent payment architecture, and the event-driven order state machines that high-volume delivery operations require.

Order Intake, Dispatch, and Restaurant Integration Architecture

A food delivery platform lives or dies on the reliability of its order dispatch pipeline. From the moment a customer submits an order to the moment a driver picks it up, every step must be durable, idempotent, and auditable.

The order model uses an orders table with a typed state machine: CART / PLACED / PAYMENT_PROCESSING / CONFIRMED / RESTAURANT_ACCEPTED | REJECTED / PREPARING / READY_FOR_PICKUP / ASSIGNED_TO_DRIVER / PICKED_UP / IN_DELIVERY / DELIVERED | FAILED | CANCELLED. Each transition writes an order_events row. The current order status is always the latest order_events entry for that order_id: never a mutable status field on the orders table. This means any downstream system (driver app, customer notification, restaurant screen) reads from the same authoritative event log.

Restaurant menu integration uses a restaurants table paired with a menu_items table and a menu_item_prices table with effective_from/effective_to dates. Price changes write a new menu_item_prices row; the active price at any point in time is always derivable. Restaurant-side order management uses a Restaurant Order Display API: restaurants accept or reject via a webhook or polling endpoint. The restaurant_response_events table records every accept/reject with timestamp and reason. If no response arrives within accept_timeout_seconds (configurable per restaurant), the order auto-cancels with reason RESTAURANT_UNRESPONSIVE and the customer is notified.

Inbound orders are processed by an idempotent order creation endpoint. The idempotency key (client-generated UUID) is stored in order_idempotency_keys with a UNIQUE constraint: duplicate submissions return the existing order, not a new one. This prevents double-orders from network retries.

Real-Time Delivery Tracking and Driver Allocation Engine

Driver location is tracked via a driver_positions table updated by heartbeat every 10 seconds while active: driver_id, latitude, longitude, heading, speed, timestamp, accuracy_meters. A driver_current_position materialised view holds the latest position per driver. PostGIS indexes enable radius queries to find all drivers within N km of a restaurant without full table scans.

Driver status uses a state machine: OFFLINE / ONLINE / ASSIGNED / PICKING_UP / DELIVERING / COMPLETING. Each transition writes a driver_status_events row. Only ONLINE and COMPLETING drivers are eligible for dispatch.

Dispatch uses a scoring function stored in a dispatch_config table, not hardcoded: score = weight_proximity x (1 / distance_to_restaurant) + weight_rating x driver_rating + weight_idle_time x idle_minutes. The dispatch engine queries eligible drivers, computes scores, and writes a dispatch_attempt row for each candidate in ranked order. If the top-ranked driver does not accept within accept_timeout_seconds, the engine moves to the next candidate and logs a dispatch_decline_events row. The full dispatch chain is preserved for SLA analysis and earnings calculation.

ETA prediction uses a delivery_eta_model: at assignment, the model inputs distance_to_restaurant, restaurant_prep_time_estimate (pulled from restaurant_prep_times config per restaurant and meal category), historical_avg_delivery_time for the route segment, and time_of_day. The predicted_delivery_at is stored on the order and broadcast to the customer. At each driver position update, ETA is recalculated and pushed via WebSocket to the customer app. ETA recalculation events write to eta_prediction_log for model refinement.

Food order delivery apps like these are built and delivered by dedicated engineering teams through our mobile app development service.

Dynamic Pricing, Promotions, and Customer Order Lifecycle

Delivery fees and surge pricing are config-driven, not hardcoded. The pricing_rules table stores: rule_type (BASE_DELIVERY_FEE | SURGE | MINIMUM_ORDER_DISCOUNT | SERVICE_FEE), applies_to (CITY | ZONE | RESTAURANT | GLOBAL), condition_params (JSONB), fee_value, and effective_from/effective_to. At order creation, the pricing engine evaluates applicable rules in priority order and writes a price_breakdown row with each fee component. The price_breakdown row is immutable after order confirmation -- pricing rule changes affect new orders only.

Surge pricing uses a zone_demand_index materialised view refreshed on a configurable interval (default 5 minutes): active_orders / available_drivers per delivery zone. When the index exceeds surge_threshold (config), the surge_pricing_active flag on the zone record flips. The surge multiplier is a piecewise function stored in surge_config, not code.

Promotions use a promotions table: promo_code, discount_type (PERCENTAGE | FIXED_AMOUNT | FREE_DELIVERY | BOGO), applies_to (ORDER | DELIVERY_FEE | ITEM), min_order_value, max_uses, per_user_limit, valid_from, valid_until, and eligible_restaurants (JSONB array or null for all). Promo redemptions write to promo_redemptions; per_user_limit is enforced by a count query on (promo_id, user_id) before redemption. Promo usage is checked against max_uses using SELECT ... FOR UPDATE to prevent overselling under concurrent redemptions.

Customer order history uses an orders_summary materialised view per user: total_orders, favourite_restaurants (by order frequency), average_order_value, last_order_at. This drives personalised recommendations. Restaurant affinity uses a restaurant_affinity_score view: (user_id, restaurant_id, affinity_score) computed from order frequency, recency, and rating weighted by recency decay.

Payment Processing, Settlements, and Platform Analytics

Payments use a payments table as the source of truth: order_id, payment_method (CARD | WALLET | CASH | VOUCHER), amount, currency, status (PENDING / AUTHORISED / CAPTURED / REFUNDED | FAILED), payment_gateway_id, and a payment_events child table recording every gateway callback. The payments table is never updated: gateway callbacks write new payment_events rows. Current payment status is always derived from the latest payment_events entry.

Idempotency at the gateway level uses a payment_idempotency_keys table: each charge attempt writes a key tied to (order_id, attempt_number). Retries after network timeout reuse the same key to prevent double-charges. Failed payment attempts write to payment_attempts with failure_code and failure_reason: this data drives retry eligibility and fraud detection.

Restaurant and driver settlements use a ledger model: settlement_ledger with (party_id, party_type [RESTAURANT | DRIVER], entry_type [ORDER_REVENUE | PLATFORM_FEE | TIP | ADJUSTMENT | PAYOUT], amount, reference_order_id, created_at). Current balance per party is computed from the ledger, never stored as a mutable field. Weekly payout runs query the ledger balance, create a payout_batches record, and write a PAYOUT entry to the ledger. The net balance resets through the ledger, not through deletion.

Platform analytics use materialised views refreshed on configurable schedules: orders_by_hour (demand heatmap), restaurant_performance_kpis (acceptance rate, prep time, cancellation rate), driver_performance_kpis (completion rate, average delivery time, on-time rate), revenue_by_zone (GMV, platform fee, net revenue). These views feed the operations dashboard without touching live transactional tables.