Boost Feature Adoption: Deeplink-Driven Discovery Campaigns with Amply

Why Users Miss Your Best Features

Before jumping into the solution, it's worth understanding why feature discovery is so hard. Most mobile apps suffer from the same three blind spots:

1. Habit loops are powerful. Once users establish a routine with your core flow, they rarely explore beyond it. They open, do their thing, and leave. That sidebar menu with your new feature? Invisible.
2. Onboarding can't cover everything. You have roughly 60 seconds of a new user's attention during first launch. You can introduce one or two concepts, tops. Everything else has to wait.
3. Changelogs don't drive behavior. A "What's New" modal on update is easily dismissed. Users don't read release notes. Showing them the feature in context is what changes behavior.

The Progressive Discovery Pattern

Progressive discovery is a design strategy where you reveal features incrementally, matching the user's growing familiarity with your app. Instead of front-loading every feature into onboarding, you introduce them gradually across sessions.

Here's the core idea applied to in-app campaigns:

• Session 1-2: Let the user settle in. They're learning your core flow.
• Session 3-5: The sweet spot. The user is engaged but not yet in a rigid habit. This is when you introduce new features.
• Session 6+: Too late for gentle nudges. The habit loop has formed. You'll need stronger intervention.

The trick is to pair this timing with a concrete action: a deeplink that takes the user directly to the feature screen, removing all friction. No hunting through menus. No guesswork. One tap, and they're experiencing the feature firsthand.

Setting Up Feature Discovery Campaigns with Amply

Let's build a real example. Say your app has an "Export to PDF" feature that's been live for a month, but adoption is flat. Here's how to set up a deeplink-driven discovery campaign using Amply.

Step 1: Define the Trigger Event

First, decide what user action should trigger the campaign. You want to catch users at a moment of engagement, right after they've completed a meaningful action in your app. This is where Amply's event-based triggering comes in.

// Track the core action that signals user engagement
// This fires when a user completes their primary workflow
AmplySDK.track("CoreActionCompleted")

In the Amply dashboard, you'll configure your campaign to trigger when the CoreActionCompleted event fires. The campaign only displays after the event, ensuring you're reaching users who are actively engaged, not passively browsing.

Step 2: Configure the Deeplink Action

Instead of showing a generic banner or tooltip, your campaign's call-to-action uses a deeplink that navigates the user directly to the feature screen. In the Amply dashboard, set the campaign action URL to your custom scheme:

happens://feature-discovery

This URL is handled by your app's deeplink handler. When the user taps the campaign CTA, they land directly on the Export feature screen with a contextual tooltip, no navigation required.

Targeting: Finding the Right Users at the Right Time

Showing a feature discovery campaign to every user is wasteful and annoying. Someone who already uses the Export feature doesn't need a nudge. A brand-new user isn't ready for it yet. Amply's targeting rules let you get precise.

Session Count Targeting

Configure your campaign to only appear during sessions 3 through 5. This is the progressive introduction window where users are comfortable with the basics but haven't locked into rigid patterns yet.

// Amply tracks session count automatically
// In the dashboard, set:
//   Session count: 3, 4, 5
//   This creates a 3-session window for progressive introduction

Negative Event Targeting

This is the most powerful part. Amply lets you target users who have not triggered a specific event. You only want to show the Export feature campaign to users who haven't used Export yet. In the Amply dashboard, add a negative event condition: exclude users who have fired FeatureXDiscovered or who have the property has_used_export = true.

// Set custom properties to track feature usage
AmplySDK.setCustomProperties(mapOf(
    "has_used_export" to false,
    "session_count" to 4
))

// When the user eventually tries the feature, update the property:
AmplySDK.setCustomProperties(mapOf(
    "has_used_export" to true
))

The combination of session count targeting and negative event targeting ensures your campaign reaches exactly the right audience: engaged users who are ready for the feature but haven't found it on their own.

Code Implementation

Here's the complete integration. The code below ties together event tracking, deeplink handling, and discovery measurement into a cohesive flow.

Deeplink Handler Setup

Register your deeplink handler early in the app lifecycle. When Amply triggers a campaign with a deeplink action, this handler routes the user to the correct screen.

// Set up the deeplink handler during app initialization
AmplySDK.setDeeplinkHandler { url ->
    when {
        url.contains("feature-discovery") -> {
            // Navigate to the feature screen
            navigateToFeatureScreen()

            // Track that the user reached the discovery screen
            AmplySDK.track("FeatureXDiscovered")
        }
        url.contains("advanced-tips") -> {
            navigateToTipsScreen()
        }
    }
}

Trigger Event Integration

Place the trigger event at the natural completion point of your core workflow. This is the moment Amply evaluates whether to show the campaign.

// Example: user finishes creating a report
fun onReportCreated(report: Report) {
    saveReport(report)

    // This event triggers Amply's campaign evaluation
    AmplySDK.track("CoreActionCompleted")

    // Amply checks:
    // 1. Is session count between 3-5?
    // 2. Has user NOT triggered "FeatureXDiscovered"?
    // 3. Is "has_used_export" still false?
    // If all conditions match -> show the discovery campaign
}

Feature Usage Tracking

Once the user actually tries the feature, track it both in Amply (to stop showing the campaign) and in your analytics platform (to measure long-term adoption).

// When the user actually uses the Export feature
fun onExportUsed(document: Document) {
    // Update Amply properties to suppress future campaigns
    AmplySDK.setCustomProperties(mapOf(
        "has_used_export" to true
    ))

    // Track in your analytics platform for adoption metrics
    Amplitude.track("FeatureXUsed", mapOf(
        "source" to "discovery_campaign",
        "session_number" to currentSessionCount
    ))
}

Measuring Feature Adoption Impact

A discovery campaign without measurement is just a guess. Here's how to build a clear picture of what's working.

The Discovery Funnel

Track three key events to build a complete adoption funnel:

1. Campaign Shown — Amply tracks this automatically. How many eligible users saw the discovery prompt?
2. Feature Discovered — Tracked via AmplySDK.track("FeatureXDiscovered"). How many users tapped through the deeplink?
3. Feature Adopted — Tracked via Amplitude.track("FeatureXUsed"). How many users came back and used the feature on their own?

What to Expect

Teams using this progressive discovery pattern with Amply typically see:

• Feature adoption increases of 20-40% within the targeted user segments.
• Clear data on which features resonate at which point in the user journey, informing your product roadmap.
• Reduced churn, because users who discover more value in your app are less likely to leave.

Conclusion

Shipping a great feature is only half the job. The other half is making sure the right users find it at the right time. With Amply's event-based triggering, session count targeting, negative event filtering, and deeplink actions, you can build discovery campaigns that feel like a natural part of the user experience rather than a disruptive popup.

The pattern is straightforward: track a core action, target users in the sessions 3-5 window who haven't yet used the feature, and deeplink them directly to the screen where they can experience it firsthand. Measure discovery and adoption separately to understand where users drop off.

Your best features deserve to be found. Stop relying on changelogs and menu exploration. Start building campaigns that bring users directly to the value you've already built for them.