Stallo Fried Chicken
Direct-to-consumer food delivery and multi-branch ordering engine for the Finnish market on iOS and Android.
Evocation-IT
Helsinki, Finland (Remote)
Contract Flutter Mobile Engineer
2025 · Production Launch
Cross-Platform Flutter Engine
Official production release on Google Play and Apple App Store (Finland)
Single Flutter codebase with native platform fidelity
From discovery to confirmed order placement
Fluid rendering across complex item modifiers and catalogs
Eliminates 20–30% aggregator commission fees on direct orders
Executive Summary
Stallo Fried Chicken is a growing restaurant brand in Finland offering premium fried chicken, burgers, sides, and signature family meals. To break reliance on third-party food aggregators that charge steep 20–30% marketplace commissions, the leadership team at Evocation-IT commissioned a dedicated, high-performance cross-platform mobile application.
I was brought on as the Lead Flutter Engineer to architect, build, and deploy the production mobile apps for Android and iOS. The mandate demanded a frictionless consumer ordering experience: multi-branch location selection, sub-second food catalog browsing, custom item modifiers (spiciness, combo sides, beverages), dynamic coupon codes, transparent checkout, and live order status tracking.
By leveraging Clean Architecture and a feature-first modular system, the application delivers fluid 60 FPS interactions, instant cart recalculations, and resilient offline handling, giving Stallo direct customer ownership and recurring brand loyalty.
The Challenge
The Challenge: Disintermediating Aggregators Without Sacrificing Consumer UX
Quick-service restaurants face an uphill battle when competing against massive food delivery aggregators like Wolt and Foodora. To succeed as a standalone direct-to-consumer channel, the native app needed to match or exceed aggregator UX standards while solving multi-branch logistical constraints.
Aggregator Margin Bleed & Brand Dilution
Paying 20–30% per order to third-party delivery networks compressed operating margins and severed direct customer relationships, preventing targeted loyalty rewards and repeat marketing.
Multi-Branch Inventory & Operational Disconnect
Different physical locations had varying opening hours, delivery radiuses, and item availability. The app needed strict branch validation so customers never ordered from closed or out-of-stock locations.
Complex Item Customization & Add-on Rules
Unlike simple retail, food ordering involves multi-level modifiers: mandatory combo choices, optional dips, item size upgrades, and special cooking notes. The state management had to be rock-solid to prevent invalid cart payloads.
Friction in Checkout & Payment Method Adaptability
Finnish diners expect flexible payment options: Cash on Delivery (COD), in-app card payments, and future local gateways. Any payment or network hiccup risked immediate basket abandonment.
Project Scope
Engineering Objectives & Delivery Scope
- Architect a maintainable, testable Flutter codebase using Clean Architecture and feature-first modularization.
- Implement real-time multi-branch sync with automatic opening hours detection and delivery radius fencing.
- Build a sub-second catalog navigation system with fluid categorization, search, and dynamic item modifiers.
- Design an atomic cart state machine that handles add-ons, quantity limits, coupon logic, and delivery fee calculation with zero race conditions.
- Integrate dual checkout options (Cash on Delivery & Secure Online Card Processing) with transactional failure safety.
- Provide end-to-end order lifecycle tracking from kitchen receipt to courier dispatch and delivery.
- Deploy production builds to Google Play Store and Apple App Store in compliance with EU privacy and store review guidelines.
Engineering Foundation
Architecture & Technical Design
To prevent technical debt and ensure longevity, the app is structured around Clean Architecture with strict separation between Presentation, Domain, Data, and Core infrastructure layers.
Feature-First Modular Layering
Each feature domain (auth, catalog, cart, checkout, orders, address) encapsulates its own presentation controllers, domain entities/use cases, and repository data sources. Cross-feature dependencies flow through explicit contracts.
Reactive Cart State Engine
Cart operations use an immutable state model that recalculates discounts, branch surcharges, delivery fees, and add-on pricing atomically. Debounced local persistence ensures cart recovery across app restarts.
Resilient Networking & Cache Boundary
Configured with Dio/Http client interceptors for automatic JWT refresh, exponential backoff retries, and offline catalog caching so flaky mobile data connections never produce empty or broken screens.
Strict Store Review Compliance
Implemented Apple & Google account deletion requirements, transparent privacy policies, GDPR consent checks, and asset optimization for swift store review approval.
Screen Walkthrough
The product, in the order a user moves
Production screens from the live apps, framed as a journey rather than a pile of captures. Follow them from the first screen to the last action.
Follow the journey →
Deep Dive
Key Technical Implementations
Detailed breakdown of core features addressing complex mobile engineering requirements.
Dynamic Food Catalog & Modifier Engine
Sub-second browsing with customized meal combinations
Quick-service restaurant menus require flexible product configurations. We engineered a dynamic modifier system supporting mandatory single-select options (e.g., choice of side), multi-select add-ons (extra cheese, jalapeños, dipping sauces), and special kitchen instructions. Prices update in real time with smooth animations and zero UI stutter.
- Nested option trees with validation for mandatory requirements before cart addition
- Real-time price recalculation that updates base price plus selected modifier differentials
- Custom dietary allergy and cooking instructions field preserved through to kitchen ticket
Multi-Branch Sync & Availability Guards
Location-aware ordering with operational boundary checks
Food cannot be ordered from a kitchen that is closed or beyond the maximum delivery radius. The app automatically checks the customer’s location or manual branch selection against the restaurant branch schedule and operational polygon before allowing order progression.
- Live branch status checking (Open, Closing Soon, Closed, Dine-in/Pickup Only)
- Delivery radius validation preventing out-of-bounds orders before reaching payment
- Branch-specific menu overrides for temporary out-of-stock items
Streamlined Checkout & Multi-Channel Payments
Dual checkout modes with transparent bill breakdown
Cart abandonment kills food delivery conversion. We refined the order summary into a clear single-screen layout featuring a Delivery vs. Takeaway Pickup toggle, instant coupon code validation, delivery surcharge calculation, and dual payment support (Cash on Delivery and Online Card Processing).
- One-tap toggle between Home Delivery and Store Pickup with dynamic fee adjustments
- Server-side coupon validation with instant feedback on minimum spend requirements
- Safe idempotency keys on payment submission to prevent double charges on slow networks
Order Status Lifecycle & Instant Reorder
Real-time kitchen feedback and historical records
Keeping customers informed reduces anxiety and support requests. Customers can track their order through a visual status stepper (Placed → Kitchen Preparing → Out with Driver → Delivered) and reorder previous favorite meals with a single tap.
- Visual status timeline reflecting real-time kitchen and courier progress
- Itemized past order receipts with tax and payment method breakdowns
- 1-tap reorder button that pre-populates the cart with previous customizations
Hurdles & Solutions
Technical Challenges & Trade-Offs
Real production obstacles overcome during engineering and deployment.
Handling Complex Multi-Tier Modifier Pricing without UI Lag
Separated modifier selection logic into a dedicated domain entity with pure functional price reducers. The presentation layer only consumes the immutable calculation, keeping the UI at 60 FPS even on low-end Android devices.
Eliminated modifier calculation bugs and ensured exact price parity between the app and the POS backend.
Preventing Double Order Submission on Unstable Mobile Connections
Implemented client-side request de-duplication with a unique UUID idempotency header per checkout attempt, paired with optimistic UI disabling on the submit button.
Zero duplicate order incidents reported in production, even when users experienced elevator cellular drops.
Dual Store Approval Guidelines (Apple & Google)
Preemptively handled in-app account deletion, localized Finnish privacy disclaimers, clear digital receipt displays, and transparent pricing disclosure.
Passed both Apple App Store Review and Google Play Console checks on first submission with zero rejections.
Outcomes
Impact & Production Outcomes
The Stallo Fried Chicken mobile applications successfully launched as the brand’s flagship direct-to-consumer digital channel in Finland. By combining a clean, appetizing design with robust mobile engineering, the app provides Finnish diners with a native, fast alternative to aggregator apps while keeping margins inside the business.
Active in production across Finnish Android & iOS app stores
First-time approval on both Google Play Store and Apple App Store
Per-order commission retained on direct customer orders
Fluid animations, smooth bottom sheets, and responsive touch feedback
Technology Breakdown
Tools, Frameworks & Libraries
Categorized technical stack employed to achieve reliability, performance, and store compliance.