'Building Context-Aware Notifications in Swift: Lessons from PushTo100'

'Building Context-Aware Notifications in Swift: Lessons from PushTo100'

• Swiftui, Pushto100, Ios, Fitness-tech • 7 min read

author: Wesley Matlock read_time: 5 —

Why Most Fitness App Notifications Suck

Notifications can make or break a fitness app. With PushTo100, I ran head-first into that truth. The problem wasn’t technical — it was behavioral. Generic reminders like “Time to move!” weren’t just ineffective… they became noise. Easy to ignore. Even easier to turn off.

What users actually needed was a nudge that felt timely. Not just in terms of clock time — I’m talking about context. Did they work out yesterday? Have they been hitting evening sessions? Are they crushing a streak or falling off one?

That’s when I started sketching the bones of a smarter system — something that wouldn’t just blast reminders, but learn when users are actually most likely to respond. Something respectful. Local-only. No creepy cloud profiling. Just a bit of logic, some thoughtful data tracking, and Swift code that could actually make a difference.

This post breaks down how I built that context-aware notification system inside PushTo100. It’s not a full-blown machine learning model — but it does learn patterns, adapt message tone, and pick smart delivery windows. We’ll walk through the architecture, dig into some code, and call out the real-world gotchas I hit along the way.

🫶 Quick thing before we keep going: If this post helps you ship cleaner code or rethink your SwiftUI approach, tapping that 👏 button (up to 50 times!) helps more iOS devs find it. Appreciate you being here.

Let’s make notifications feel like a coach — not a robot.

🏗 Architecture Overview: Three-Tier Intelligence System

We built this around three layers:

  1. Pattern Analysis Engine — figures out when the user works out
  2. Adaptive Messaging System — tailors what to say based on user state
  3. Smart Scheduling Engine — figures out when to say it

All of it lives in the same Swift module. Access control and feature gating check if the user is on the premium tier. Notifications themselves are triggered through local scheduling.

You don’t need a remote service. All the analysis happens locally. The only external dependency is the user showing up.

📊 Pattern Analysis: Teaching the App to Learn

We track historical user behavior and build lightweight user models based on local activity. The core struct looks like this:

struct SmartPatterns {  
    var preferredTimes: [PreferredTime]  
    var dayPreferences: [Int: Double]  
    var consistencyScore: Double  
    var averageSessionGap: Double  
    var bestPerformanceDays: [Int]  
}

func calculateSuccessRates(workouts: [WorkoutEvent]) -> [Int: Double] {  
    // dayOfWeek: completion rate  
}

Key logic we added:

  • Rolling 30-day activity window
  • Weighted scores: recent behavior matters more
  • Ignore users until they’ve logged enough sessions (min threshold)

Trick: For new users, we default to general motivational reminders until the system “warms up.”

💬 Adaptive Messaging: Context-Aware Motivation

Messages are generated based on streaks and success rates.

Streak Tiers:

Performance-Based Frequency:

func motivationalMessage(forUser user: SmartUser) -> String {  
    switch user.successRate {  
    case 0..<0.4: return "🛌 Haven’t seen you in a while. Let’s get back on track?"  
    case 0.4..<0.6: return "Small steps count. Let’s try something light today?"  
    case 0.6..<0.8: return "You’re finding your groove—want to keep it up?"  
    default: return "You’re crushing it. 🔥 Stay in the zone."  
    }  
}

Messages are localized, emoji-friendly, and never shaming.

⏰ Smart Scheduling: Sending the Right Nudge at the Right Time

There are three kinds of notification events:

  1. Adaptive Reminders — based on user success rates and active time slots
  2. Motivational Timers — scheduled check-ins (morning boost, afternoon push, evening wrap)
  3. Triggered Events — like finishing a workout or hitting a milestone

From the engine:

private func scheduleAdaptiveReminder(for patterns: SmartPatterns) {  
    let optimalTime = patterns.preferredTimes.max { $0.successRate < $1.successRate }  
    // Schedule local notification  
}

🔐 Premium vs Free: Feature Gating with Respect

Free users:

  • Daily static nudges at fixed times
  • Basic motivational content

Premium users:

  • Full behavior tracking
  • Smart time prediction
  • Adaptive message tone
  • Rest/recovery detection

Example gating logic:

func scheduleSmartReminder(context: ModelContext) async {  
    let hasAccess = await checkPremiumAccess()
    
    guard hasAccess else {  
        await scheduleBasicReminder()  
        return  
    }
    
    await scheduleAdvancedSmartReminder(context: context)  
}

✅ Testing Strategy: Make It Reliable or Don’t Ship It

Tests include:

  • Pattern analysis with edge cases
  • Message tone validation
  • Scheduling accuracy
func testCalculateSuccessRates_accuracy() {  
    let workouts = generateMockEvents()  
    let results = calculateSuccessRates(workouts)  
    XCTAssertEqual(results[1], 0.75) // Monday example  
}

There’s also a simple SwiftUI debug view for manual trigger testing.

⚡️ Performance & Privacy

  • 100% local processing
  • No CoreML
  • No cloud dependencies
  • No analytics data exported
  • Designed with GDPR in mind

Background processing is lightweight and only triggers on usage events.

📈 Metrics That Actually Matter

Post-launch for PushTo100, we saw:

  • 2.4x higher notification open rates
  • 30% more workouts completed after notifications
  • Notification disable rates cut in half
  • Premium upgrades increased due to personalized value

🔮 Lessons and What’s Next

What We Learned:

  • Timing > frequency
  • Streak reinforcement is powerful
  • Users respond to tone
  • Local-first is absolutely doable

What’s Next:

  • Sleep-aware reminders using HealthKit
  • Calendar-based time suggestions
  • Social features for friend-based nudging
  • More personalization per region

🧰 Want to Build This Yourself?

Start small:

  1. Track basic workout patterns — day, time, frequency
  2. Schedule notifications based on historical success windows
  3. Build message templates with tone that adapts to user behavior
  4. Add premium gating if needed, but keep the core respectful
  5. Build lightweight tests to confirm accuracy and avoid regressions

You don’t need a machine learning model. You need meaningful data, clean logic, and empathy.

Whether you’re building your first fitness app or adding motivation to an existing habit tracker, this notification engine can scale with you — and your users.

🛫 Wrap-Up

Building a smarter notification system wasn’t about chasing buzzwords. It was about listening to what users actually respond to — then writing Swift code that could meet them halfway. In PushTo100, that meant ditching the noisy “don’t forget to workout!” spam and building a coach that paid attention. If you want to see the app in action, check out PushTo100.com or download it from the App Store.

You don’t need a machine learning model to make notifications feel smart. Just track what matters, test what you send, and respect the user’s rhythm. Because at the end of the day, it’s not about reminding them. It’s about understandingthem.

Smart notifications aren’t about the tech — they’re about the timing.

🎯 Bonus: More Real-World iOS Survival Stories

If you’re hungry for more tips, tricks, and a few battle-tested stories from the trenches of native mobile development, swing by my collection of articles: https://medium.com/@wesleymatlock

Originally published on Medium

Originally published on Medium

← Back to Blog