Concept project completed as part of the CareerFoundry Product Design program. Not affiliated with, endorsed by, or commissioned by Tim Hortons. All brand names and marks belong to their respective owners.
Project Overview
The Tim Hortons AI Assist project reimagines mobile coffee ordering as a conversation. Instead of navigating through menus, multiple wizards, and customization screens, customers place an order by simply saying what they want , "my usual," "a medium iced capp, less ice", and a conversational AI assistant builds, confirms, and checks out the order inside a single persistent chat thread.
Problem:
Tim Hortons app and kiosk customers struggle to navigate the menu, customize their orders, and decide what to order. These issues lead to longer ordering times, missed personalized recommendations, and increased frustration. The current system lacks real-time, interactive assistance, which negatively impacts user experience, customer satisfaction, and loyalty.
Goal:
Design and integrate an AI chatbot into the Tim Hortons app that delivers personalized recommendations, streamlines ordering, and offers instant support , targeting a 20% increase in repeat customers and a 15% increase in new customers within six months.
My role:
Product Designer, end-to-end. I owned the experience strategy, user flows, interaction design, the design system, prototyping, and usability testing. My background in Quality Engineering and Business Analysis shaped a systems-led, risk-aware approach. It treats edge cases, error states, and technical constraints as first-class design inputs.
Responsibilities:
Problem definition & How-Might-We framing
Competitive analysis (Starbucks, McDonald's)
Persona & user stories
User-journey-map workshop facilitation
User flows
Mid-fidelity wireframes
Usability test plan, moderation & reporting
Hi-fidelity design system (color, type, spacing, and radius tokens)
Interactive prototype
Component library
Developer handoff
Solution:
A conversational ordering feature inside the Tim Hortons iOS app: a persistent scrolling chat thread with natural-language understanding. First-time and returning users get tailored paths. New users get onboarding. Returning users get "my usual" and saved-payment fast-tracking. The experience includes a universal store picker, size-gated drink customization, graceful error and out-of-stock handling, and in-thread support.
User Research
Research combined two methods: secondary/competitive analysis of how Starbucks and McDonald's handle mobile ordering and AI, and workshop-based journey mapping with stakeholders and users to locate the emotional low points in the current Tim Hortons ordering experience.
DEFINE
With research in hand, I turned findings into a clear point of view: the ordering experience fails at three moments, deciding, customizing, and getting help, and a conversational assistant could collapse all three into one thread. I grounded this in a persona, Alyssa, and a set of pain points drawn from the journey-map workshop.
Pain Points
Decision
Faced with a large menu, customers hesitate over what to order and miss items suited to them. There's no guidance and no memory of past orders.
Customization
Modifying an order (size, sugar, milk, ice) means navigating multiple screens. It's easy to get wrong and slow to correct.
Support & recovery
When something goes wrong (wrong item, missing item, failed payment), there's no fast, in-context way to get help without leaving the flow.
User Personas
Research signals synthesized into one representative user. Alyssa anchors every design decision that follows.
User Journey Map
Goal
Ideate
With the problem defined, I moved from insight to structure, starting at the customer's biggest friction ("what do I order, and how do I change it?") and mapping a conversational flow that keeps steps minimal for both first-time and returning users.
User Flow
Alyssa's path from opening the app to order confirmation. The flow branches for first-time and returning users, keeping steps minimal on both paths.
I built the flow by analyzing the existing Tim Hortons app structure and identifying friction points for new vs. returning users. The flow starts post-login and branches: first-time users get onboarding (welcome, how-it-works, store selection) before ordering; returning users skip straight to "my usual" with their store and saved payment pre-loaded. Both paths converge through natural-language ordering → customization → review → pickup & payment → confirmation, with support and cancel branches available throughout.
Information Architecture
The app's structure, organized around a single conversational surface. Because the AI assistant handles ordering in one thread, most screens collapse into states, not pages — keeping navigation shallow and the next action always obvious.
I structured the information architecture by mapping the full journey from login to order confirmation and identifying the decision-heavy moments along it. Because ordering lives in one persistent chat thread, most screens collapse into states rather than pages, grouped by intent: Decide, Customize, Review, Pay, Confirm. New and returning user logic separates right after login, which keeps both paths short instead of forcing one path to carry every condition. Each state shows only what that step requires — support and cancel stay reachable from anywhere in the thread, and anything that could distract from the current action was cut. The result is a structure where the next action is always obvious, which is what guidance over choice looks like at the architecture level.
Paper Wireframes
Quick pen-and-paper structure for every screen in Alyssa's flow, from app open to confirmation. Testing hierarchy and intent before any pixels.
I sketched the full journey on paper first, one frame per stage from app open to confirmation. Working this fast made structural problems cheap to find and fix. Each sketch answered two questions: what does Alyssa need to see here, and what one action should it drive? Anything that competed with that action was cut before reaching digital, giving me a validated skeleton to refine rather than discover.
Digital Wireframes
I translated the paper skeleton into low-fidelity wireframes using AI-assisted tools, primarily UX Pilot alongside ChatGPT, to generate screen structure quickly and explore layout variations at speed. This let me cover the complete flow for both first-time and returning users in a fraction of the usual time, then curate and refine the output rather than draw every frame from scratch. Working this way kept the focus on structure and intent over pixel-pushing, and reflects how I actually work: using AI as a production partner while owning every design decision.
Usability Studies
I conducted usability testing with three participants on the mid-fidelity prototype, before high-fidelity design. Testing the core ordering flow surfaced the friction points that shaped every later decision.
Participants completed core tasks such as ordering their usual coffee or snack, adding items mid-order, and cancelling before payment while thinking aloud. Sessions ran 10–15 minutes, using Jakob Nielsen's severity scale (0–4) to prioritize findings. The focus was on identifying confusion and friction so the flow could be simplified before high-fidelity design.
Issues:
Couldn't type in the text field, forcing button taps (sev. 4)
No "reorder previous order" option (sev. 3)
"Coffee" quick action opened the wrong screen
Add card missing (sev. 4)
Reordering took 3–4 steps, users expected 2
No quantity, remove, or "add more" at checkout (sev. 4)
Solution:
Made the input a true text field for plain-language ordering
Added a "my usual" / last-order reorder path
Fixed routing so "Coffee" opens coffee
AI prompts to use saved payment for one-tap pay
Compressed reordering to two steps
Added inline quantity, remove, and "add more"
Design
With the structure validated, I moved from wireframes to the final visual experience choosing iOS native as the platform. Rather than explore a new visual direction, I anchored the design to Tim Hortons' existing brand, so the interface would feel native to the app customers already know. From there I built a token-driven design system (color, typography, spacing, radius, and iconography) so every screen draws from the same rules instead of one-off decisions.
I then used AI as a production partner to generate first-draft screens from that system, and took full ownership in Figma, refining every screen, adding scenarios and edge cases, and making the design decisions that shaped the final experience for both first-time and returning users.
Design system
A cohesive foundation that defines the app's visual identity through structured color, accessible typography, spacing, and reusable components, all anchored to the Tim Hortons brand and built to Apple's iOS Human Interface Guidelines.
I built a working system, not a set of one-off screens, with AI as an accelerator. Starting from Tim Hortons' current color palette, I generated primitive color ramps and fed them into semantic tokens that carry roles: a warm-neutral foundation for calm, the brand red for primary actions, green for success, and amber for warnings. Spacing, radius, and typography live in variable sets for consistency across every screen.
Because this is a native iOS app, the system follows Apple's Human Interface Guidelines: SF Pro typography, 44pt tap targets, and native patterns. I defined the tokens in Figma first, then imported the system into Claude Design to build from. The strictest rule is the smallest one: a screen references a role, not a hex, which keeps the design consistent, accessible, and scalable by construction.
HiFi Design & Prototype
Detailed, interactive version of the design that closely reflects the final product's visual style, functionality, and overall experience.
Generated the first screens in Claude Design by importing my design system and building the initial layouts there, reaching a first version with minimal edits.
Brought the screens into Figma, where I built out the full high-fidelity design, refined every layout, and made the detailed design decisions.
Expanded the flow with real-world scenarios, adding screens for new user, returning users, errors, out-of-stock items, cancellation, and order-scoped support, iterating with AI (Claude, ChatGPT, Gemini) as a thinking partner.
Refined typography, color, and component consistency so every screen draws from the same system.
Strengthened visual cues such as recommendations, status cards, and CTA prominence for clarity.
Followed Apple's HIG for a native iOS feel: 44pt tap targets, system-style sheets, and a clean thumb-friendly vertical flow.
Outcome
The outcome is a working, interactive prototype of a mobile-first conversational ordering experience. I self-tested the full flow end to end and pressure-tested design decisions with AI tools (Claude, ChatGPT, Gemini) along the way. Every screen answers the customer's core need, get me what I want, fast, and let me fix it if it's wrong, replacing menu-navigation friction with plain-language ordering for both first-time and returning users.
Takeaways
A working prototype is a stronger artifact than static screens, it lets you feel the conversation, not just look at it.
AI as a design accelerator changes the process: small features and screen variations that would take hours by hand can be generated in minutes, freeing time for the decisions that actually matter.
Conversation beats navigation, letting users type "my usual" removed the single biggest friction testing surfaced.
Risk-aware design pays off, treating error, out-of-stock, and wrong-store states as first-class produced a flow with no dead ends
Impact:
Delivered a complete, handoff-ready design: tokenized, accessible, componentized, with first-time and returning flows and full edge-case coverage.
AI-assisted workflow compressed the timeline, generating first-draft screens from the design system meant I spent my time refining and deciding, not drawing from scratch.
The system is reusable by construction, a component library and token set that scale to new screens without rework.
What I learned:
Designing with AI as a first-class tool is a genuinely different design process, and a valuable one. The real skill isn't generating screens; it's building the system and making the decisions that direct the AI. I learned that AI is fastest at the repeatable and structural work (screen variants, states, token application) and that human judgment still owns hierarchy, edge cases, and whether something feels right. I also learned to treat AI as a review partner, using it to pressure-test flows and surface gaps, not to replace design thinking.
Next Steps
Extend to Android native, adapting the iOS system to Material Design patterns (navigation, components, and motion) so the experience feels native on both platforms.
Enhance the AI assistant with richer conversation features such as group orders, dietary preferences, and smarter reorder suggestions.
Deepen in-thread support so the assistant resolves order issues end-to-end without leaving the conversation.
Conduct moderated usability testing with a broader group of Tim Hortons customers, both app regulars and first-time users, to validate the conversational ordering thesis at scale.
Pressure-test the AI's error and out-of-stock handling with real ordering scenarios.
Private content
Enter the password to continue.
Don't have the password? Contact me on LinkedIn click here