Cursor rule

1---
2description: User journey optimization patterns for all POS roles with performance, UX, and business outcome focus
3---
4 
5# 👥 User Journey Optimization & Role-Specific Patterns
6 
7## 🎯 Journey-First Design Philosophy
8 
9### Performance Targets by Role
10```typescript
11interface RolePerformanceTargets {
12  admin: {
13    dashboardLoad: '< 2 seconds',
14    reportGeneration: '< 5 seconds',
15    userManagement: '< 1 second per action',
16    systemOverview: '< 1.5 seconds'
17  },
18  server: {
19    orderCreation: '< 30 seconds total',
20    productSelection: '< 5 seconds per item',
21    tableAssignment: '< 3 seconds',
22    customerInteraction: 'seamless, no delays'
23  },
24  counter: {
25    paymentProcessing: '< 10 seconds',
26    orderTypeSwitch: '< 2 seconds',
27    receiptGeneration: '< 3 seconds',
28    queueManagement: 'real-time updates'
29  },
30  kitchen: {
31    statusUpdates: '< 1 second',
32    orderPrioritization: 'real-time',
33    workflowOptimization: 'continuous',
34    communicationDelay: '< 2 seconds'
35  }
36}
37```
38 
39## 👑 Admin Journey Optimization
40 
41### 1. Executive Dashboard Experience
42```typescript
43// ✅ ADMIN-OPTIMIZED: Executive dashboard with business intelligence
44class AdminDashboardOptimization {
45  // Intelligent data aggregation for C-level insights
46  async loadExecutiveDashboard(): Promise<ExecutiveDashboard> {
47    // Parallel data loading for instant insights
48    const [
49      realtimeMetrics,
50      financialSummary,
51      operationalHealth,
52      staffPerformance,
53      customerSatisfaction,
54      systemAlerts
55    ] = await Promise.all([
56      this.getRealtimeBusinessMetrics(), // Revenue, orders/hour, avg ticket
57      this.getFinancialSummary(), // Daily/weekly/monthly trends
58      this.getOperationalHealth(), // Kitchen efficiency, table turnover
59      this.getStaffPerformance(), // Individual and team metrics
60      this.getCustomerSatisfaction(), // Wait times, order accuracy
61      this.getSystemAlerts() // Technical and business alerts
62    ])
63 
64    // Business intelligence: Automatic insights generation
65    const insights = this.generateBusinessInsights({
66      metrics: realtimeMetrics,
67      trends: financialSummary,
68      operations: operationalHealth
69    })
70 
71    return {
72      kpis: this.createKPIDashboard(realtimeMetrics),
73      trends: this.createTrendAnalysis(financialSummary),
74      alerts: this.prioritizeAlerts(systemAlerts),
75      recommendations: insights.recommendations,
76      quickActions: this.generateQuickActions(insights)
77    }
78  }
79 
80  // Predictive business insights
81  private generateBusinessInsights(data: DashboardData): BusinessInsights {
82    const insights: BusinessInsight[] = []
83 
84    // Revenue optimization insights
85    if (data.metrics.averageTicket < data.historical.averageTicket * 0.95) {
86      insights.push({
87        type: 'revenue_optimization',
88        severity: 'medium',
89        title: 'Average Ticket Size Declining',
90        description: 'Consider implementing upselling strategies or menu optimization',
91        actionable: true,
92        quickActions: [
93          { label: 'View Menu Performance', action: 'navigate_to_menu_analytics' },
94          { label: 'Staff Upselling Training', action: 'create_training_task' }
95        ]
96      })
97    }
98 
99    // Operational efficiency insights
100    if (data.operations.kitchenEfficiency < 0.85) {
101      insights.push({
102        type: 'operational_efficiency',
103        severity: 'high',
104        title: 'Kitchen Efficiency Below Target',
105        description: 'Kitchen preparation times are impacting customer satisfaction',
106        actionable: true,
107        quickActions: [
108          { label: 'View Kitchen Analytics', action: 'navigate_to_kitchen_dashboard' },
109          { label: 'Optimize Kitchen Workflow', action: 'open_workflow_optimizer' }
110        ]
111      })
112    }
113 
114    return {
115      insights,
116      recommendations: this.generateActionableRecommendations(insights),
117      predictedImpact: this.calculatePredictedBusinessImpact(insights)
118    }
119  }
120}
121 
122// Admin interface switching optimization
123class AdminInterfaceSwitching {
124  // Seamless role interface switching with context preservation
125  async switchToRoleInterface(targetRole: UserRole, preserveContext: boolean = true): Promise<void> {
126    // Pre-load target interface data
127    const targetData = await this.preloadRoleData(targetRole)
128    
129    if (preserveContext) {
130      // Preserve admin context for quick return
131      this.preserveAdminContext({
132        currentDashboard: this.getCurrentDashboardState(),
133        activeReports: this.getActiveReports(),
134        notifications: this.getPendingNotifications()
135      })
136    }
137 
138    // Optimized transition with loading states
139    this.showTransitionLoading(`Switching to ${targetRole} interface...`)
140    
141    // Load role-specific optimizations
142    const roleOptimizations = await this.loadRoleOptimizations(targetRole)
143    
144    // Smooth transition with preserved user experience
145    this.transitionToRoleInterface(targetRole, targetData, roleOptimizations)
146  }
147 
148  // Role-specific data preloading
149  private async preloadRoleData(role: UserRole): Promise<RoleData> {
150    const preloadStrategies = {
151      server: () => Promise.all([
152        this.menuService.getAvailableProducts(),
153        this.tableService.getAvailableTables(),
154        this.orderService.getActiveOrders()
155      ]),
156      counter: () => Promise.all([
157        this.orderService.getPendingPayments(),
158        this.paymentService.getPaymentMethods(),
159        this.customerService.getLoyaltyPrograms()
160      ]),
161      kitchen: () => Promise.all([
162        this.kitchenService.getActiveOrders(),
163        this.kitchenService.getPreparationQueue(),
164        this.kitchenService.getKitchenStations()
165      ])
166    }
167 
168    return preloadStrategies[role]?.() || Promise.resolve(null)
169  }
170}
171```
172 
173## 🍽️ Server Journey Optimization
174 
175### 1. Lightning-Fast Order Creation
176```typescript
177// ✅ SERVER-OPTIMIZED: Fastest possible order creation workflow
178class ServerOrderOptimization {
179  // Intelligent product suggestions based on context
180  async optimizeProductSelection(context: ServerContext): Promise<ProductSuggestions> {
181    const suggestions = await Promise.all([
182      this.getPopularItems(), // Most ordered items today
183      this.getSeasonalRecommendations(), // Weather/season based
184      this.getTableSpecificSuggestions(context.table_id), // Table history
185      this.getTimeBasedSuggestions(), // Lunch vs dinner items
186      this.getInventoryOptimizedItems() // Items needing to move
187    ])
188 
189    return {
190      quickAccess: suggestions[0].slice(0, 8), // 8 most popular for instant access
191      recommended: this.mergeAndRankSuggestions(suggestions),
192      categories: await this.getOptimizedCategories(),
193      searchSuggestions: await this.getIntelligentSearchSuggestions()
194    }
195  }
196 
197  // Voice-optimized order taking
198  async enableVoiceOrderAssistance(): Promise<VoiceAssistant> {
199    return {
200      startListening: () => {
201        // "Large pepperoni pizza, extra cheese, side of wings"
202        this.voiceRecognition.listen({
203          grammar: 'restaurant_menu',
204          continuous: true,
205          confidenceThreshold: 0.8
206        })
207      },
208 
209      processVoiceOrder: async (transcript: string) => {
210        // AI-powered menu item extraction
211        const extractedItems = await this.nlpService.extractMenuItems(transcript)
212        
213        // Confidence-based confirmation
214        return extractedItems.map(item => ({
215          product: item.product,
216          quantity: item.quantity,
217          confidence: item.confidence,
218          needsConfirmation: item.confidence < 0.9,
219          suggestedAlternatives: item.confidence < 0.7 ? item.alternatives : []
220        }))
221      },
222 
223      provideFeedback: (feedback: VoiceFeedback) => {
224        // "I heard 'large pepperoni pizza', is that correct?"
225        this.speakConfirmation(feedback)
226      }
227    }
228  }
229 
230  // Gesture-based order modification
231  async enableGestureControls(): Promise<GestureController> {
232    return {
233      // Swipe gestures for quantity adjustment
234      onSwipeRight: (item: OrderItem) => this.incrementQuantity(item),
235      onSwipeLeft: (item: OrderItem) => this.decrementQuantity(item),
236      
237      // Pinch to remove items
238      onPinch: (item: OrderItem) => this.removeItemWithConfirmation(item),
239      
240      // Long press for customization
241      onLongPress: (item: OrderItem) => this.showCustomizationOptions(item),
242      
243      // Double tap for quick add
244      onDoubleTap: (product: Product) => this.quickAdd(product)
245    }
246  }
247 
248  // Predictive text for special instructions
249  async generateInstructionPredictions(partialText: string): Promise<string[]> {
250    const commonInstructions = await this.getCommonInstructions()
251    const contextualPredictions = await this.getContextualPredictions(partialText)
252    
253    return [
254      ...contextualPredictions.slice(0, 3),
255      ...commonInstructions
256        .filter(instruction => instruction.startsWith(partialText.toLowerCase()))
257        .slice(0, 5)
258    ]
259  }
260}
261 
262// Server-specific UI optimizations
263class ServerUIOptimization {
264  // Large touch targets for tablet use
265  generateTouchOptimizedUI(): ServerUIConfig {
266    return {
267      buttonSize: {
268        primary: '60px', // Easy finger tap
269        secondary: '48px',
270        icon: '44px' // Apple's minimum recommended
271      },
272      
273      spacing: {
274        between_products: '12px',
275        section_margins: '24px',
276        safe_area: '16px' // Away from screen edges
277      },
278      
279      typography: {
280        product_names: '18px', // Easy to read while moving
281        prices: '16px bold',
282        descriptions: '14px',
283        min_line_height: '1.4'
284      },
285      
286      interaction: {
287        tap_feedback: 'haptic + visual',
288        loading_states: 'skeleton_shimmer',
289        error_display: 'inline_toast',
290        success_confirmation: 'checkmark_animation'
291      }
292    }
293  }
294 
295  // Context-aware interface adaptation
296  async adaptToEnvironment(context: EnvironmentContext): Promise<UIAdaptation> {
297    const adaptations = {
298      lighting: {
299        bright: { theme: 'light', contrast: 'high' },
300        dim: { theme: 'dark', contrast: 'enhanced' },
301        changing: { theme: 'auto', contrast: 'adaptive' }
302      },
303      
304      noise_level: {
305        quiet: { audio_feedback: 'subtle' },
306        normal: { audio_feedback: 'standard' },
307        loud: { audio_feedback: 'enhanced', visual_feedback: 'prominent' }
308      },
309      
310      rush_period: {
311        true: { layout: 'simplified', animations: 'reduced', shortcuts: 'enabled' },
312        false: { layout: 'full', animations: 'smooth', shortcuts: 'optional' }
313      }
314    }
315 
316    return this.applyAdaptations(adaptations, context)
317  }
318}
319```
320 
321## 💰 Counter Journey Optimization
322 
323### 1. Multi-Modal Payment Excellence
324```typescript
325// ✅ COUNTER-OPTIMIZED: Seamless payment processing for all order types
326class CounterPaymentOptimization {
327  // Intelligent payment method selection
328  async optimizePaymentMethods(order: Order, customer: Customer): Promise<PaymentOptimization> {
329    const recommendations = await this.analyzePaymentPreferences({
330      order_total: order.total_amount,
331      customer_history: customer?.payment_history,
332      current_promotions: await this.getActivePromotions(),
333      loyalty_benefits: await this.getLoyaltyBenefits(customer),
334      time_of_day: new Date().getHours()
335    })
336 
337    return {
338      recommended_method: recommendations.primary,
339      alternatives: recommendations.alternatives,
340      
341      // Smart suggestions
342      split_payment_options: recommendations.split_options,
343      tip_suggestions: this.calculateOptimalTipSuggestions(order.total_amount),
344      loyalty_redemptions: recommendations.loyalty_opportunities,
345      
346      // UX optimizations
347      quick_amounts: this.generateQuickAmountButtons(order.total_amount),
348      keyboard_shortcuts: this.getPaymentKeyboardShortcuts(),
349      receipt_options: this.getReceiptPreferences(customer)
350    }
351  }
352 
353  // Lightning-fast receipt generation
354  async generateOptimizedReceipt(payment: Payment): Promise<ReceiptGeneration> {
355    // Parallel processing for speed
356    const [
357      receiptData,
358      loyaltyUpdate,
359      businessAnalytics,
360      customerCommunication
361    ] = await Promise.all([
362      this.formatReceiptData(payment),
363      this.updateLoyaltyPoints(payment.customer_id, payment.amount),
364      this.recordBusinessMetrics(payment),
365      this.prepareCustomerCommunication(payment)
366    ])
367 
368    // Smart receipt customization
369    const receiptCustomization = await this.customizeReceipt({
370      customer_preferences: payment.customer?.receipt_preferences,
371      business_branding: await this.getBrandingElements(),
372      promotional_messages: await this.getContextualPromotions(payment),
373      next_visit_incentives: await this.generateRetentionOffers(payment.customer_id)
374    })
375 
376    return {
377      receipt: this.combineReceiptElements(receiptData, receiptCustomization),
378      delivery_methods: this.determineDeliveryMethods(payment.customer),
379      follow_up_actions: this.generateFollowUpActions(payment)
380    }
381  }
382 
383  // Queue management optimization
384  async optimizeCounterQueue(): Promise<QueueOptimization> {
385    const queueAnalysis = await this.analyzeCurrentQueue()
386    
387    return {
388      // Intelligent order routing
389      order_routing: {
390        express_line: queueAnalysis.simple_orders, // < 3 items, card payment
391        full_service: queueAnalysis.complex_orders, // Large orders, special requests
392        pickup_only: queueAnalysis.pickup_orders // Pre-paid online orders
393      },
394      
395      // Staff allocation suggestions
396      staffing_recommendations: {
397        current_efficiency: queueAnalysis.efficiency_score,
398        suggested_stations: queueAnalysis.optimal_station_count,
399        cross_training_opportunities: queueAnalysis.skill_gaps
400      },
401      
402      // Customer communication
403      wait_time_estimates: {
404        express: this.calculateExpressWaitTime(),
405        full_service: this.calculateFullServiceWaitTime(),
406        accuracy_confidence: queueAnalysis.prediction_confidence
407      }
408    }
409  }
410}
411 
412// Counter-specific multi-tasking optimization
413class CounterMultitaskingOptimization {
414  // Context switching between order types
415  async enableSeamlessOrderTypeSwitch(): Promise<OrderTypeSwitcher> {
416    return {
417      // Maintain context across switches
418      preserveContext: (currentOrder: PartialOrder, targetType: OrderType) => {
419        const adaptedOrder = this.adaptOrderToType(currentOrder, targetType)
420        
421        return {
422          preserved_items: adaptedOrder.compatible_items,
423          modified_items: adaptedOrder.modified_items,
424          additional_fields: adaptedOrder.required_fields,
425          ui_adaptations: adaptedOrder.ui_changes
426        }
427      },
428 
429      // Quick switch shortcuts
430      keyboard_shortcuts: {
431        'Alt+D': 'switch_to_dine_in',
432        'Alt+T': 'switch_to_takeout', 
433        'Alt+L': 'switch_to_delivery',
434        'Alt+P': 'switch_to_phone_order'
435      },
436 
437      // Visual transition optimization
438      transition_animation: 'slide_with_context_preservation',
439      loading_state: 'skeleton_with_preserved_data',
440      error_recovery: 'restore_previous_context'
441    }
442  }
443 
444  // Parallel order processing
445  async enableParallelOrderHandling(): Promise<ParallelProcessor> {
446    return {
447      // Handle multiple orders simultaneously
448      concurrent_orders: {
449        max_concurrent: 3, // Based on cognitive load research
450        context_switching_delay: 200, // ms buffer for mental switching
451        visual_indicators: 'color_coded_tabs',
452        keyboard_navigation: 'tab_cycling'
453      },
454 
455      // Smart notifications
456      notification_management: {
457        priority_system: 'payment_ready > order_complete > new_order',
458        consolidation_rules: 'group_similar_events',
459        quiet_hours: 'reduce_non_critical_notifications',
460        escalation_policy: 'manager_alert_after_5min'
461      }
462    }
463  }
464}
465```
466 
467## 👨‍🍳 Kitchen Journey Optimization
468 
469### 1. Intelligent Workflow Orchestration
470```typescript
471// ✅ KITCHEN-OPTIMIZED: Real-time workflow optimization with AI assistance
472class KitchenWorkflowIntelligence {
473  // AI-powered order prioritization
474  async optimizeKitchenWorkflow(): Promise<WorkflowOptimization> {
475    const currentState = await this.getKitchenCurrentState()
476    const orderComplexity = await this.analyzeOrderComplexity()
477    const staffCapacity = await this.assessStaffCapacity()
478    
479    // Machine learning for optimal sequencing
480    const optimizedSequence = await this.mlOrderSequencer.optimize({
481      pending_orders: currentState.pending_orders,
482      preparation_times: orderComplexity.estimated_times,
483      staff_availability: staffCapacity.current_capacity,
484      equipment_status: currentState.equipment_availability,
485      
486      // Business constraints
487      customer_wait_targets: this.getWaitTimeTargets(),
488      vip_priorities: currentState.vip_orders,
489      delivery_deadlines: currentState.delivery_orders
490    })
491 
492    return {
493      recommended_sequence: optimizedSequence.order_sequence,
494      parallel_preparation: optimizedSequence.parallel_opportunities,
495      resource_allocation: optimizedSequence.staff_assignments,
496      time_estimates: optimizedSequence.completion_predictions,
497      
498      // Proactive insights
499      bottleneck_warnings: optimizedSequence.potential_bottlenecks,
500      efficiency_score: optimizedSequence.predicted_efficiency,
501      customer_impact: optimizedSequence.customer_satisfaction_impact
502    }
503  }
504 
505  // Real-time kitchen coaching
506  async provideRealTimeCoaching(): Promise<KitchenCoach> {
507    return {
508      // Preparation guidance
509      step_by_step_guidance: async (order: KitchenOrder) => {
510        const recipe = await this.getOptimizedRecipe(order)
511        const chef_level = await this.getChefSkillLevel()
512        
513        return this.adaptGuidanceToSkill(recipe, chef_level)
514      },
515 
516      // Timing optimization
517      timing_alerts: {
518        prep_start_warnings: '2min before optimal start time',
519        cooking_reminders: 'stage-based timer alerts',
520        plating_readiness: 'when all components ready',
521        service_window: 'optimal serving temperature window'
522      },
523 
524      // Quality assurance
525      quality_checkpoints: {
526        visual_inspection: 'AI-powered image analysis for plating',
527        temperature_monitoring: 'smart probe integration',
528        portion_validation: 'weight-based portion control',
529        completion_verification: 'checklist completion tracking'
530      }
531    }
532  }
533 
534  // Intelligent communication system
535  async enableSmartKitchenCommunication(): Promise<CommunicationSystem> {
536    return {
537      // Contextual messaging
538      smart_notifications: {
539        server_updates: 'automatic ETA updates to servers',
540        customer_alerts: 'delay notifications with alternatives',
541        management_reports: 'efficiency and issue summaries',
542        cross_station_coordination: 'synchronized preparation alerts'
543      },
544 
545      // Voice-activated controls
546      voice_commands: {
547        status_updates: '"Order 123 ready for pickup"',
548        requests_help: '"Need assistance at grill station"',
549        inventory_alerts: '"Running low on chicken"',
550        quality_issues: '"Hold order 456 - refire needed"'
551      },
552 
553      // Visual communication
554      display_optimization: {
555        color_coding: 'priority and status color system',
556        progress_indicators: 'visual preparation progress bars',
557        station_coordination: 'cross-station dependency visualization',
558        urgency_signals: 'escalating visual alerts for delayed orders'
559      }
560    }
561  }
562 
563  // Predictive kitchen analytics
564  async generatePredictiveInsights(): Promise<KitchenPredictiveAnalytics> {
565    const historicalData = await this.getKitchenHistoricalData()
566    const currentTrends = await this.getCurrentTrends()
567    
568    return {
569      // Preparation time predictions
570      prep_time_forecasting: {
571        individual_orders: this.predictOrderPreparationTime,
572        batch_optimization: this.predictBatchCookingOpportunities,
573        rush_period_planning: this.predictRushPeriodCapacity,
574        staff_scheduling: this.predictOptimalStaffLevels
575      },
576 
577      // Quality predictions
578      quality_risk_assessment: {
579        ingredient_freshness: this.predictIngredientOptimalUsage,
580        equipment_maintenance: this.predictEquipmentMaintenanceNeeds,
581        recipe_consistency: this.predictQualityDeviations,
582        customer_satisfaction: this.predictCustomerSatisfactionImpact
583      },
584 
585      // Business impact forecasting
586      business_impact_predictions: {
587        revenue_optimization: this.predictRevenueImpactOfEfficiency,
588        cost_reduction: this.predictCostSavingOpportunities,
589        customer_retention: this.predictCustomerRetentionImpact,
590        staff_satisfaction: this.predictStaffSatisfactionImpact
591      }
592    }
593  }
594}
595```
596 
597## 🔄 Cross-Journey Integration Patterns
598 
599### 1. Seamless Handoff Optimization
600```typescript
601// ✅ INTEGRATION: Seamless data flow between all user journeys
602class CrossJourneyIntegration {
603  // Real-time state synchronization
604  async synchronizeUserJourneys(): Promise<JourneySyncManager> {
605    return {
606      // Order lifecycle synchronization
607      order_handoffs: {
608        server_to_kitchen: {
609          data_transfer: 'complete_order_context',
610          timing_optimization: 'immediate_kitchen_notification',
611          error_handling: 'bidirectional_communication'
612        },
613        
614        kitchen_to_counter: {
615          data_transfer: 'completion_status_with_quality_notes',
616          timing_optimization: 'proactive_payment_preparation',
617          error_handling: 'automatic_status_rollback'
618        },
619        
620        counter_to_admin: {
621          data_transfer: 'financial_and_operational_metrics',
622          timing_optimization: 'real_time_dashboard_updates',
623          error_handling: 'data_consistency_verification'
624        }
625      },
626 
627      // Context preservation across roles
628      context_handoffs: {
629        admin_to_role_switch: 'preserve_oversight_context',
630        emergency_escalation: 'full_context_transfer_to_management',
631        shift_changes: 'comprehensive_state_transfer'
632      },
633 
634      // Performance monitoring across journeys
635      journey_performance: {
636        end_to_end_tracking: 'customer_order_journey_timing',
637        bottleneck_detection: 'cross_role_workflow_analysis',
638        optimization_suggestions: 'multi_role_efficiency_improvements'
639      }
640    }
641  }
642 
643  // Intelligent notification routing
644  async createIntelligentNotificationSystem(): Promise<NotificationRouter> {
645    return {
646      // Context-aware routing
647      route_notification: (notification: Notification, context: SystemContext) => {
648        const routing = this.calculateOptimalRouting(notification, context)
649        
650        return {
651          primary_recipients: routing.immediate_action_required,
652          secondary_recipients: routing.awareness_only,
653          escalation_chain: routing.escalation_sequence,
654          delivery_methods: routing.optimal_delivery_channels
655        }
656      },
657 
658      // Intelligent aggregation
659      aggregate_notifications: (notifications: Notification[]) => {
660        return {
661          grouped_by_context: this.groupRelatedNotifications(notifications),
662          prioritized_by_business_impact: this.prioritizeByBusinessImpact(notifications),
663          optimized_for_attention: this.optimizeForUserAttention(notifications)
664        }
665      },
666 
667      // Feedback loop optimization
668      notification_effectiveness: {
669        track_response_times: 'measure_action_completion_speed',
670        measure_attention_impact: 'cognitive_load_assessment',
671        optimize_delivery_timing: 'learn_optimal_notification_windows'
672      }
673    }
674  }
675}
676```
677 
678This user journey optimization framework ensures each role has a perfectly tuned experience while maintaining seamless integration across the entire POS system. The patterns focus on real business outcomes, user satisfaction, and operational efficiency.
679 
680<function_calls>
681<invoke name="todo_write">
682<parameter name="merge">true