See your app the way your users experience it.

Gatepost is a real-user performance monitoring SDK for iOS, Android and cross-platform apps. It measures cold start, screen rendering, network calls and crashes on real devices, then delivers the data to the collector closest to the user.

Free for one app and 250,000 sessions a month. No card needed.

session 8f3c41d0Android 15, LTE, cold start
App launch812 ms
First frame93 ms
Screen: Home275 ms
GET /catalog143 ms
Image decode185 ms, slow frame
Screen: Product180 ms
POST /cart210 ms
app startscreennetworkslow frame
380 KBSDK size on iOS, arm64
< 3 msadded to cold start, p95
61 msmedian upload latency to the nearest collector
99.98%ingest availability, last 90 days

From first install to first insight in one afternoon

Gatepost instruments the common cases automatically and stays out of your release process.

Add the SDK

One dependency and one init call. Automatic instrumentation covers app start, screens, HTTP clients and crashes.

Ship a build

Nothing changes in how you release. Sampling and upload rules live in the console, not in code, so you can adjust them without a new build.

Data reaches the nearest collector

Devices batch telemetry and post it to a regional collector over HTTPS. Uploads stay short even on weak mobile networks.

Look at real sessions

Percentiles per screen, release and device class, and a full session trace when a number needs an explanation.

What Gatepost measures

The metrics mobile teams actually get asked about, attributed to the screen, release and device where they happened.

App start

Cold, warm and hot starts split into phases: process launch, framework init, first frame, first interaction. Know which phase got slower, and in which release.

Screen rendering

Time to first frame per screen, slow and frozen frames, scroll hitches. Each one attributed to the screen and the release it happened in.

Network

Latency, payload size, TLS handshake time and failures for every HTTP request, grouped by host and route template rather than raw URL.

Crashes and ANRs

Symbolicated crash reports and Android ANR traces, linked to the session that led up to them so you can see what the user did first.

Custom traces

Wrap any operation in a trace and attach attributes. Checkout, image upload, database migration: whatever your users wait for.

Release comparison

Compare any two builds side by side. Catch a regression on a 2% rollout before it reaches everyone.

Built for the constraints of a phone

A monitoring SDK that slows the app down is measuring itself. Gatepost is sized and scheduled to disappear into the noise.

iOSAndroid
SDK size, compiled arm64380 KB410 KB
Added to cold start, p952.6 ms2.9 ms
Memory at restunder 1.5 MBunder 2 MB
BatteryNo wake locks. Uploads ride on radio activity the app already causes.
OfflineEvents are buffered on disk for up to 24 hours and sent in order.
UploadGzip-compressed batches up to 256 KB over HTTPS, at most once per 30 seconds.

Telemetry goes to the nearest collector

Every project is assigned a collector host in its home region. The SDK resolves it once and posts batched events to /v1/rum/<PROJECT_KEY> and spans to /v1/traces/<PROJECT_KEY>, retrying with backoff if the network drops.

Collectors are stateless ingest endpoints. They validate the project key, accept the batch with 202 Accepted and hand it to your project's storage region. Nothing is kept on the collector itself.

Read the ingest API reference

  • Regions. Europe, Russia and CIS, Middle East, Asia-Pacific, North and South America. Data residency is fixed per project and never changes because of where a device happens to be.
  • Health checks. Each collector exposes /health for uptime monitoring and a /diagnostics page you can open on a device to verify reachability from a specific network.
  • Write-only keys. A project key can send events and nothing else. A key leaked from a decompiled app cannot read your data.
  • Short connections. Batches are small and sent over the connection the app already has open, so cellular radios go back to sleep quickly.

Two lines to start, one to trace anything

Automatic instrumentation gets you app start, screens, network and crashes. Custom traces cover the rest.

Swift, SwiftUI app
import Gatepost

@main
struct ShopApp: App {
    init() {
        Gatepost.start(projectKey: "<PROJECT_KEY>") {
            $0.sampleRate = 0.25
            $0.trackNetwork = true
        }
    }
    var body: some Scene {
        WindowGroup { RootView() }
    }
}

// anywhere in the app
let trace = Gatepost.trace("checkout.submit")
trace.set("items", cart.count)
try await api.submit(cart)
trace.end()
Kotlin, Android
import org.mustgate.gatepost.Gatepost

class ShopApp : Application() {
    override fun onCreate() {
        super.onCreate()
        Gatepost.start(this, "<PROJECT_KEY>") {
            sampleRate = 0.25
            trackNetwork = true
        }
    }
}

// anywhere in the app
val trace = Gatepost.trace("checkout.submit")
trace["items"] = cart.size
api.submit(cart)
trace.end()

What teams say after the first release

We cut cold start by 38% in two releases. Not because the tool is magic, but because for the first time we could see which init phase was slow on mid-range Android.

Daria K., lead mobile engineer, grocery delivery app

The session trace is the thing. A number tells you a screen is slow. A trace tells you why.

Tomasz W., iOS developer, retail banking app

Our previous tool added 4 MB to the APK. Gatepost added 400 KB and the argument about monitoring simply ended.

Ilya S., head of mobile, marketplace app

Start measuring in an afternoon

Add the SDK, ship a build and look at your first real sessions before the day is over. The free plan covers one app and 250,000 sessions a month.