How I Built a Deep Linking Service That Resolves in Under 10ms (and Why You Might Need One)

OBHOLZ SOLUTIONS — Mon, 06 Apr 2026 18:14:29 +0000

How I Built a Deep Linking Service for Mobile Apps Using Cloudflare Workers

If you've ever built a mobile app, you know the pain of deep linking. You share a link, the user taps it, and you want them to land on the right screen inside your app -- not the home screen, not the app store listing, the exact content they were looking for.

Simple in theory. A nightmare in practice.

The State of Deep Linking in 2026

Firebase Dynamic Links was the go-to free option for years. Then Google shut it down. Overnight, thousands of apps needed a replacement.

Branch.io is the market leader, but their pricing starts well into the hundreds per month. For an indie developer or early-stage startup, that's a hard sell for what is essentially a redirect service with some fingerprinting logic.

I'm Stefan, an indie developer from Germany, and I decided to build something better. LinkHopp is a deep linking platform that's fast, affordable, and developer-friendly. Here's how it works under the hood.

The Architecture: Edge-First Everything

The core insight is that a deep link redirect is latency-sensitive. The user tapped a link and is waiting. Every millisecond matters.

LinkHopp's redirect logic runs entirely on Cloudflare Workers -- deployed to 300+ edge locations worldwide. When a user clicks a LinkHopp URL:

The Worker receives the request at the nearest edge location
Link metadata is fetched from Cloudflare KV (cached at the edge)
The Worker parses the User-Agent, determines the platform
The user is redirected to the appropriate destination

No origin server in the critical path. No cold starts. In my benchmarks, resolution typically takes single-digit milliseconds at the edge.

The Hard Part: Deferred Deep Linking

Standard deep linking is straightforward -- if the app is installed, open it with the right parameters. But what about users who don't have the app yet?

Deferred deep linking means: user clicks link -> goes to app store -> installs app -> opens app -> lands on the correct content. The challenge is maintaining context across an app store install, where you lose all URL parameters.

LinkHopp uses a 3-stage matching approach:

Stage 1: Deterministic match. On Android, the Google Play referrer API can pass a click ID through the install. This gives an exact match about 30% of the time. On iOS, this rarely works.

Stage 2: Fuzzy fingerprint. When a user clicks a link, we store a fingerprint (IP hash + User-Agent + screen resolution + locale + timezone) in Cloudflare KV with a 24-hour TTL. When the app opens for the first time, the SDK sends the same signals, and we match against recent clicks. This is the workhorse -- it handles the majority of matches.

Stage 3: Probabilistic fallback. When Stage 2 returns multiple candidates, we use a narrower feature set and confidence scoring to pick the best match.

In my testing, this achieves match rates around 85-90% depending on the traffic mix and platform.

GDPR by Design

All IP addresses are hashed (SHA-256) before storage. Fingerprints auto-delete after 24 hours. There's no persistent user tracking, no cross-app profiles, no data brokering. LinkHopp routes links -- that's it.

Integrating LinkHopp: Flutter SDK

Getting started takes about 5 minutes. Install the package from pub.dev:

# pubspec.yaml
dependencies:
  linkhopp: ^1.0.0

Initialize the SDK in your app:

import 'package:linkhopp/linkhopp.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();

  await LinkHopp.init(
    apiKey: 'your_api_key',
    onDeepLink: (DeepLinkResult result) {
      // result.path   -> e.g., "/products/42"
      // result.params -> {"referrer": "campaign_summer"}
      // result.matchType -> MatchType.exact | .fingerprint | .probabilistic
      navigateTo(result.path, queryParams: result.params);
    },
  );

  runApp(MyApp());
}

The SDK handles Universal Links (iOS), App Links (Android), and deferred deep link matching automatically. The matchType field tells you how the match was made so you can adjust your UX accordingly -- for example, showing a confirmation for probabilistic matches.

Creating Links via the REST API

You can create deep links programmatically from your backend:

curl -X POST https://linkhopp.com/api/v1/links \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "destination_url": "https://yourapp.com/products/42",
    "ios_url": "https://apps.apple.com/app/id123456",
    "android_url": "https://play.google.com/store/apps/details?id=com.yourapp",
    "campaign": "summer_launch",
    "utm_source": "devto",
    "utm_medium": "article"
  }'

Response:

{
  "id": "...",
  "short_code": "xK9mQ",
  "short_url": "https://linkhopp.com/xK9mQ",
  "destination_url": "https://yourapp.com/products/42",
  "created_at": "2026-03-28T10:00:00Z"
}

The API also supports A/B test variants, geo-targeted redirects, and QR code generation. Full docs at linkhopp.com/docs.

Honest Comparison: When to Use What

I'm not going to pretend LinkHopp does everything Branch.io does. Branch has been around for over a decade, has hundreds of employees, and offers features like cross-platform attribution, deep integrations with ad networks, and NativeLink technology.

Here's where the two differ:

Feature	LinkHopp	Branch.io
Deep linking (iOS + Android)	Yes	Yes
Deferred deep linking	Yes	Yes
Redirect speed	Single-digit ms (edge)	Varies
Flutter SDK	Yes (pub.dev)	Yes
React Native SDK	Yes (npm)	Yes
A/B Testing	Yes	Yes
Geo-Targeting	Yes	Yes
QR Codes	Built-in	Built-in
Ad network attribution	No	Yes
Cross-platform user graphs	No	Yes
Free tier	1,000 clicks/mo	Limited
Starting price	$49/mo	Contact sales

Choose Branch if you need ad network attribution or cross-platform identity graphs.

Choose LinkHopp if you need reliable deep linking, deferred deep links, and analytics at a price that won't eat your runway.

What's Next

I'm actively working on:

Link previews dashboard -- real-time preview of how your links render on social platforms
Slack/Discord webhooks -- get notified when links hit milestones
Self-hosted option -- deploy LinkHopp on your own Cloudflare account

Try It Out

LinkHopp has a free tier with 1,000 clicks per month -- no credit card required. Paid plans start at $49/month.

Website: linkhopp.com
Flutter SDK: pub.dev/packages/linkhopp
React Native SDK: npmjs.com/package/linkhopp-react-native
API Docs: linkhopp.com/docs

If you have questions about the architecture or want to talk deep linking, drop a comment below. I built this as an indie developer and I'm happy to help anyone working through mobile deep linking challenges.

I built a Branch.io alternative for $79/mo instead of $499

OBHOLZ SOLUTIONS — Sun, 22 Mar 2026 21:11:08 +0000

I built a Branch.io alternative for $79/mo instead of $499

Firebase Dynamic Links shut down in August 2025. Branch.io costs $499/month. I needed deep linking for my Flutter app and didn't want to pay enterprise prices for a feature that should be simple.

So I built LinkHopp — deep linking, deferred deep linking, and campaign tracking for $49-99/month.

The Problem

If you're building a mobile app, you need deep links. When someone shares a link to your app:

Desktop → open your website
Mobile + app installed → open directly in the app
Mobile + app NOT installed → go to App Store, then open the app to the right screen after install

That last one is called deferred deep linking, and it's surprisingly hard to get right. Firebase Dynamic Links used to do this for free. Now it's dead. Branch.io does it, but costs $499/month with mandatory "Contact Sales" calls.

What LinkHopp Does

Deep Linking — iOS Universal Links + Android App Links
Deferred Deep Linking — 3-stage matching (Play Install Referrer → Clipboard → Fuzzy Fingerprint) with ~90% match rate
Sub-10ms Redirects — Cloudflare KV Cache at 300+ edge locations worldwide
Campaign Tracking — UTM parameters, click stats by device/country/day
A/B Testing — Split traffic between multiple destinations
Geo-Targeting — Different URLs per country
QR Codes — Generated per link via API
Webhooks — Get notified when links are clicked
Smart Banners — "Open in App" banner for mobile web visitors

The Tech Stack

Cloudflare Workers (Redirect Engine + API)
  └── KV Cache (sub-10ms link lookups)
Supabase (PostgreSQL + Auth + RLS)
SvelteKit on Cloudflare Pages (Dashboard)
Flutter SDK + React Native SDK
Stripe (Billing)

Total infrastructure cost at 0 customers: ~$5/month (Supabase Pro). At 100 customers: ~$30/month. Margins are 95%+.

How the Matching Works

When someone clicks a LinkHopp link on mobile and doesn't have the app:

Before redirect: We save a fingerprint (hashed IP, OS, device model, language, timezone, screen size) and generate a unique token
Android: Token goes into the Play Store Install Referrer URL — Google passes it through to the app after install (~98% match rate)
iOS: Token gets written to clipboard via a brief interstitial page — app reads it on first launch (~60% with clipboard, users see iOS paste banner)
Fallback: Fuzzy fingerprint matching with weighted scoring — IP(40pts) + OS(15) + Device(15) + Language(10) + Timezone(10) + Screen(10), threshold 70/100

The fuzzy matching uses partial scores: "iOS 17.4" vs "iOS 17.5" gives 80% points, not 0. "de-DE" vs "de-AT" gives 70%. This catches OS updates and regional variants that would otherwise be false negatives.

What Makes This Different from Branch

	Branch	LinkHopp
Price	$499+/mo	$49-99/mo
Redirect Speed	~200ms	<10ms (KV Cache)
Pricing	"Contact Sales"	Self-service, transparent
Flutter SDK	Wrapper around native	Native Dart
Firebase Migration	"Contact Sales"	Self-service import tool
Setup Time	Days	10 minutes

Pricing

Free: 1,000 clicks/month, 1 project
Starter ($49): 50,000 clicks/month, 3 projects
Pro ($79): 200,000 clicks/month, 10 projects, A/B testing
Business ($99): 1M clicks/month, unlimited projects, custom domain

Try It

Website: linkhopp.com
API Docs: linkhopp.com/docs
Flutter SDK: linkhopp on pub.dev
React Native SDK: @linkhopp/react-native on npm

The onboarding takes 2 minutes: register → create project → get API key → create your first link.

If you're migrating from Firebase Dynamic Links, there's a built-in import tool that converts your existing links automatically.

Built solo with Cloudflare Workers + Supabase + SvelteKit. Questions? Ask in the comments.

DEV Community: OBHOLZ SOLUTIONS

How I Built a Deep Linking Service That Resolves in Under 10ms (and Why You Might Need One)

How I Built a Deep Linking Service for Mobile Apps Using Cloudflare Workers

The State of Deep Linking in 2026

The Architecture: Edge-First Everything

The Hard Part: Deferred Deep Linking

GDPR by Design

Integrating LinkHopp: Flutter SDK

Creating Links via the REST API

Honest Comparison: When to Use What

What's Next

Try It Out

I built a Branch.io alternative for $79/mo instead of $499

I built a Branch.io alternative for $79/mo instead of $499

The Problem

What LinkHopp Does

The Tech Stack

How the Matching Works

What Makes This Different from Branch

Pricing

Try It