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.
GET /catalog143 msPOST /cart210 msFrom 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.
| iOS | Android | |
|---|---|---|
| SDK size, compiled arm64 | 380 KB | 410 KB |
| Added to cold start, p95 | 2.6 ms | 2.9 ms |
| Memory at rest | under 1.5 MB | under 2 MB |
| Battery | No wake locks. Uploads ride on radio activity the app already causes. | |
| Offline | Events are buffered on disk for up to 24 hours and sent in order. | |
| Upload | Gzip-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.
- 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
/healthfor uptime monitoring and a/diagnosticspage 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.
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()
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.