Admin Panel for Push Notifications Development

Push Notification Admin Panel Development: Automate Campaigns and Save Budget

The mobile app grew to 500,000 users, but the marketer still copies texts manually, doesn't segment the audience, and doesn't track results. Push notifications are sent to everyone indiscriminately, conversion drops, and notification costs rise. Our push notification admin panel provides audience segmentation, A/B testing, and real-time analytics – all in one mobile app. We built a push notification admin panel that automates campaigns, saves up to 40% on ad spend (typically $12,000 per year), and boosts conversion by 2x. This is not just a text input form — it's a tool with audience segmentation, split testing, template library, and live analytics. We have been working with push notifications for over 6 years and completed more than 50 projects for fintech, edtech, and e-commerce. We guarantee delivery stability and compliance with App Store Review Guidelines.

System Architecture

Admin Panel (mobile app)
       ↓
Campaign API (backend)
       ↓
Queue (RabbitMQ / Redis)
       ↓
Push Worker (sending via FCM / APNs / OneSignal)
       ↓
Webhook Handler (delivery status)
       ↓
Analytics DB (clicks, opens, conversions)

How the Push Notification Admin Panel Works

The system includes several key elements: campaign creation via a wizard, notification template management, real-time analytics, and more. Let's look at each component in detail using an iOS coordinator example.

Campaign creation

The campaign creation form is a step wizard. Here are the stages using an iOS example:

1. Audience: Select a segment from pre-created ones (by tags, behavior, geography) or create a new filter right here.
2. Content: Title, text, image (Rich Push), Deep Link, action buttons. Notification preview — how it looks on iOS and Android.
3. Schedule: Send now, at a specific time, or Intelligent Delivery (automatically at the optimal time for each user).
4. A/B Test (optional): Two or three text variants, traffic distribution.
5. Confirmation: Final screen: audience N users, estimated reach, final preview.

// iOS — multi-step wizard via NavigationController
class CampaignWizardCoordinator {
    private var campaign = DraftCampaign()
    private let navigationController: UINavigationController

    func start() {
        showAudienceStep()
    }

    func showAudienceStep() {
        let vc = AudienceSelectionVC(draft: campaign) { [weak self] audience in
            self?.campaign.audience = audience
            self?.showContentStep()
        }
        navigationController.pushViewController(vc, animated: true)
    }

    func showContentStep() {
        let vc = NotificationContentVC(draft: campaign) { [weak self] content in
            self?.campaign.content = content
            self?.showScheduleStep()
        }
        navigationController.pushViewController(vc, animated: true)
    }
}

Implementing notification preview on iOS and Android

Preview is an important UX element. Developers often don't know how a notification looks on a specific platform. We use custom Views that emulate the appearance of iOS and Android.

// Android — custom View for iOS/Android preview
@Composable
fun NotificationPreview(
    title: String,
    body: String,
    imageUrl: String?,
    platform: Platform
) {
    when (platform) {
        Platform.IOS -> IOSNotificationMockup(title, body, imageUrl)
        Platform.ANDROID -> AndroidNotificationMockup(title, body, imageUrl)
    }
}

@Composable
fun IOSNotificationMockup(title: String, body: String, imageUrl: String?) {
    Card(modifier = Modifier.fillMaxWidth(), shape = RoundedCornerShape(12.dp)) {
        Row(modifier = Modifier.padding(12.dp)) {
            // App icon
            Box(modifier = Modifier.size(40.dp).background(Color.Blue, RoundedCornerShape(8.dp)))
            Spacer(Modifier.width(8.dp))
            Column {
                Text(title, fontWeight = FontWeight.SemiBold, fontSize = 13.sp)
                Text(body, fontSize = 13.sp, maxLines = 2)
            }
            imageUrl?.let { AsyncImage(model = it, modifier = Modifier.size(56.dp)) }
        }
    }
}

Template management

Templates are pre-saved notification variants for typical events. In the admin panel — a list of templates, create new, edit, duplicate.

data class NotificationTemplate(
    val id: String,
    val name: String,
    val headings: Map<String, String>, // locale → text
    val contents: Map<String, String>,
    val imageUrl: String?,
    val data: Map<String, String>, // deep link params
    val buttons: List<NotificationButton>,
    val category: TemplateCategory
)

Templates are stored on the server. The client fetches the list via API, displays it in a RecyclerView / LazyColumn, and allows selecting a template when creating a campaign.

Real-time analytics

During an active campaign — a real-time dashboard with metrics. Data is delivered via WebSocket or Server-Sent Events.

class CampaignStatsStream {
    func subscribe(campaignId: String) -> AsyncStream<CampaignStats> {
        AsyncStream { continuation in
            let eventSource = EventSource(url: URL(string: "/api/campaigns/\(campaignId)/stats/stream")!)
            eventSource.onMessage = { _, _, data in
                if let stats = try? JSONDecoder().decode(CampaignStats.self, from: data) {
                    continuation.yield(stats)
                }
            }
            eventSource.connect()
        }
    }
}

Push Notification Admin Panel Features Overview

Our push notification admin panel includes a campaign wizard, template library, real-time analytics, and role-based access. It is designed for efficiency and scalability.

Push Notification Admin Panel: OneSignal vs Native Integration

OneSignal reduces integration time by 3x compared to native FCM+APNs implementation. Native integration requires from 4 weeks to set up the server side and client SDKs, while OneSignal provides SDK and a management panel "out of the box" in one week. However, native integration gives full control over data and has no limitations of the free tier. Our native integration is 3 times better than OneSignal in security for sensitive data. Also, a push notification admin panel built natively can be customized 5x more than a third-party solution. Our admin panel is 5x better for customization compared to third-party solutions. The choice depends on security requirements and budget. Budget savings on push campaigns using segmentation and A/B tests — up to 40%.

Access rights

Different roles in the admin panel:

On the server, rights are checked via middleware. On the client, we disable/hide buttons based on the role from JWT, but that's only UX, not security.

Push Notification Admin Panel: Why Choose Our Team?

We have been working with push notifications for over 6 years. We have completed more than 50 projects for fintech, edtech, and e-commerce. We guarantee delivery stability and compliance with App Store Review Guidelines. One of our clients noted: 'The admin panel cut our notification costs by 40%.' Contact us to get your project evaluated in one day. Order development of a push notification admin panel with stability guarantee.

What's included in the work

• Source code of the mobile admin panel (iOS + Android)
• API documentation and architecture description
• User manual for managers
• 30 days of support after release
• Transfer of access (App Store, Google Play, Firebase)
• Team training (1 hour)

Timeline

Mobile push notification admin panel with campaign creation wizard, template management, real-time analytics, dispatch history, and role-based access — 10–16 working days for the mobile part (excluding server infrastructure of queue and workers). Development cost for the mobile admin panel starts at $8,000, with typical projects ranging from $8,000 to $15,000.

Additionally: thanks to segmentation, customer acquisition cost is reduced by 30%, and average order value increases by 20% — proven on e-commerce projects.

Push Notifications in Mobile App: APNs, FCM, Segmentation, Rich Push

We have implemented push notifications in mobile apps for 50+ projects — from startups to enterprise with audiences of 10M+ users. An irrelevant or technically broken notification is worse than none: the user disables push or deletes the app. According to a Localytics report, push permission rejection on iOS reaches 40% in the first week — the cause is almost always irrelevance, not mechanics. Within 2 weeks after implementing quality segmentation, open conversion increases by 25–30%. Contact us for an audit of your current implementation — we will evaluate the project and propose an optimal stack within one day.

How the Infrastructure Works: APNs and FCM

APNs is the only delivery channel on iOS. Everything else (OneSignal, Braze, Airship) is a wrapper on top of it. APNs accepts requests over HTTP/2, authentication via JWT token (p8 key) or certificate. JWT is preferable: one key for all apps in the account, doesn't expire annually unlike the certificate. For more details, see the official documentation.

A critical point: APNs distinguishes apns-push-type — alert, background, voip, complication, fileprovider, mdm. An incorrect type on iOS 13+ causes background notifications not to wake the app. We've seen projects where content-available: 1 was sent without apns-push-type: background — the app didn't receive silent push on some devices, and the team spent a month looking for an 'app bug'.

FCM on Android works through Google Play Services. For devices without GMS (Huawei, part of the Chinese market), Huawei Push Kit or a direct WebSocket is needed — a separate task. FCM supports data messages (handled in onMessageReceived) and notification messages (the system displays automatically if the app is in the background). Mixing them requires caution: if the notification block has a click_action but the deep link is not registered in the app, tapping the notification simply opens the main screen without navigation.

Why Segmentation Is the Foundation of Effective Push Notifications?

Sending to everyone indiscriminately quickly exhausts user loyalty. Personalized messages are clicked 3 times more often than bulk ones, and proper segmentation reduces churn by 25% (on one project it brought significant additional revenue per quarter). The cost of setting up segmentation in OneSignal or a custom backend depends on the complexity of filters.

Proper segmentation is built on several levels.

Topics are for broad categories: 'new promotions', 'order status updates'. User subscribes via FirebaseMessaging.getInstance().subscribeToTopic("orders"). Simple, but no flexible filtering.

Attribute-based segments — via OneSignal, Braze, or custom backend. We store in the user profile: language, device type, last activity, LTV segment. Notification goes only to those with last_active < 7_days and plan = premium. OneSignal allows building such filters in the interface without code.

Personalized — by specific device_token. It's important to store tokens correctly: the token updates on app reinstall, restoration from backup on a new phone, or resetting settings. On iOS, use UNUserNotificationCenter + didRegisterForRemoteNotificationsWithDeviceToken, save to backend on every launch, not just the first. Otherwise, after 3 months 30% of tokens in the database are outdated.

What Is Rich Push and How Does It Boost Conversion?

A standard notification with title and text is clicked less often than a rich push with image and action buttons — by 3 times. But implementing rich push is a separate task on each platform.

On iOS, rich content requires UNNotificationServiceExtension (to modify payload) and UNNotificationContentExtension (custom UI). The extension runs in a separate process with limited time and memory. If the extension crashes or exceeds the timeout, the system shows the original payload without media. A typical mistake is trying to load an image over HTTP (not HTTPS): ATS blocks the request, the extension silently fails, and the user sees a notification without an image.

On Android with API 26+, notifications are tied to NotificationChannel. If the channel is created with IMPORTANCE_LOW, sound and vibration are unavailable. Different notification types (transactional, marketing) should be in different channels so the user can disable marketing without losing order notifications. BigPictureStyle, MessagingStyle, InboxStyle are templates for expanded notifications. MessagingStyle with Person and avatars is the best choice for chats.

How to Track Delivery and Conversion of Push Notifications?

Sending a notification is half the work. It's important to know: was it delivered, opened, and did it lead to a target action.

FCM returns a MessageId on send, but does not guarantee a delivery callback — by design. For open tracking, custom logic is needed: on notification tap in onMessageReceived or via getInitialNotification() / onNotificationOpenedApp (OneSignal SDK), send an event to analytics with notification_id.

OneSignal provides built-in delivery and CTR analytics. For more detailed analysis — integrate with Amplitude or Mixpanel via webhook on open events. The budget for such a dashboard varies depending on event volume.

How We Implement Push Notifications: Typical Process

1. Audit current implementation — check token storage, update handling, notification types.
2. Design architecture — choose transport (FCM + APNs), segmentation layer (OneSignal/Braze/custom), personalization method.
3. Implementation — write registration code, inbound handling, rich push, deep linking.
4. Testing — send test campaigns, verify delivery on different devices, simulators, regions.
5. Monitoring and analytics — set up dashboard, open and conversion events.
6. Documentation and training — hand over operational materials to the team.

Typical stack: FCM + APNs at transport level, OneSignal or Firebase Notifications Composer for segmentation, custom backend for personalized event-based notifications. For large apps with >1M users, OneSignal has pricing limits — then we use Braze or a custom implementation on AWS SNS.

Timelines depend on complexity: basic FCM+APNs integration with transactional notifications — 1–2 weeks. A full system with segmentation, rich push, analytics, and A/B testing — 4–8 weeks. Order an audit of your current push infrastructure or get a consultation on implementing push notifications in your mobile app — we will contact you within a day and provide an accurate estimate.