The bouncer your phone runs before your screen turns on
Your phone gets dozens of push notifications an hour. Maybe hundreds if you've got a busy Slack workspace and a group chat that refuses to die. But only some of them wake the screen. A calendar reminder lights it up instantly. A background refresh from your podcast player? Nothing. That gap isn't random. There's an actual priority system at work, and once you understand it, you'll stop blaming your settings every time something seems off.
The short answer: every notification carries a priority level set by the app developer, filtered through the operating system's own rules, and then cross-checked against your personal settings. All three layers have to agree before your screen flips on.
The priority number nobody mentions
On Android, notifications get one of five importance levels, ranging from IMPORTANCE_MIN (no sound, no visual interruption whatsoever) up to IMPORTANCE_HIGH, which makes noise and pops onto the screen. Developers set a default when they build the app, and that default lives inside what Android calls a notification channel. A messaging app might put direct messages on a high-importance channel and promotional emails on a low one. The system reads that channel setting before it does anything else.
Apple's approach is different but lands in roughly the same place. iOS uses a combination of delivery priority (time-sensitive, active, passive, or silent) and a feature called Focus filters. Time-sensitive notifications, like a medication reminder or a ride-share driver pulling up outside, are explicitly allowed to break through Focus modes. Passive notifications, like a news digest, get delivered quietly to the notification center. No sound. No screen wake.
Here's the wrinkle, though: developers self-report these priority levels. A badly behaved app can mark everything as time-sensitive just to guarantee visibility. Both Apple and Google have started pushing back on this. Apple requires developers to apply for an entitlement to use the Time Sensitive category and actually reviews those requests. It's not airtight enforcement, but it's not purely the honor system either.
What the OS checks before anything else
Assume an app correctly labels a notification as high priority. The operating system still runs its own checklist.
First: is the screen already on? If it is, most platforms skip the wake step entirely and show a heads-up banner. The power cost is already paid.
Second: what's the device doing? Android has a concept called Doze mode. When your phone is stationary, unplugged, and the screen is off, Doze aggressively batches network access and holds low-priority notifications in a queue, sometimes for several minutes. High-priority notifications sent with a specific FCM (Firebase Cloud Messaging) flag bypass Doze and arrive immediately. This is why your alarm app wakes the screen but a social media like notification sometimes shows up in a cluster the moment you pick up your phone.
Third: does the notification carry a full-screen intent? This is the mechanism that makes an incoming call take over your entire display rather than appearing as a small banner at the top. It's a special permission that apps have to request explicitly. Android 14 tightened the rules here after some apps started using full-screen intents to display ads. Which, yes, really happened.
Your settings are the final checkpoint
All of that happens before your personal preferences even enter the picture. Then the system checks your settings, and this is the part most guides skip entirely.
Consider a plausible scenario. You have an Android phone, and you've left your messaging app on its default notification channel. The developer marked that channel as IMPORTANCE_HIGH. You're in Do Not Disturb mode but you've allowed starred contacts as an exception. A message arrives from someone you haven't starred. The notification is high importance, the app is behaving correctly, the message is real. The screen stays dark anyway, because your DND exception list didn't include that sender.
This is where most "why didn't my notification wake my screen" complaints actually live. Not a bug. Not a misbehaving app. A permission conflict at the personal-settings layer.
On iOS, the equivalent is the Focus mode contact list. If your Work Focus only allows notifications from your manager and your partner, a high-priority calendar invite from a colleague goes silent until you turn Focus off.
Battery optimization adds yet another variable. Both Android and iOS can quietly restrict background activity from apps the system decides you rarely use. An app that hasn't been opened in weeks might see its push delivery slowed even if the notification itself is marked urgent.
What people get wrong about this
The most common misconception is that notification behavior is a single toggle. People turn off Allow Notifications for an app and expect total silence, then are surprised when the app still delivers lock-screen banners (because banners and sounds are separate permissions on iOS). Or they enable all notifications and assume everything will wake the screen, not realizing that "deliver quietly" is sometimes the default for newly installed apps.
The other big one: confusing a screen wake with a notification delivery. Your phone can receive a notification, log it in the notification shade, and never wake the display. This happens constantly with passive-priority notifications. The alert arrived. You just didn't see it, because the system correctly decided it wasn't urgent enough to interrupt you.
And the subtlest mistake: assuming the app controls everything. Developers set defaults. You override them. The OS arbitrates. When something behaves unexpectedly, the cause is almost always at the intersection of two of those three layers, not a single point of failure.
The practical part
If a notification you care about isn't waking your screen, check three things in this order: the app's notification channel settings (Android) or notification delivery style (iOS), your current Focus or Do Not Disturb exceptions, and your battery optimization settings for that specific app.
If a notification you don't care about keeps waking your screen, find its channel, drop its importance level, or switch it to deliver quietly. You're not disabling the notification. You're demoting it to a level the system will handle without flipping on your display.
Your phone isn't making random decisions. It's running a deterministic hierarchy, and once you know the order of operations, you can actually predict what will happen. The system was designed so developers can guarantee their urgent alerts get through. The side effect is that you can engineer exactly the level of interruption you want, if you know where to look.