bitdrift
PricingDocs

Mobile observability,
radically reimagined

bitdrift flips the decades-old mobile observability paradigm on its head: log everything, intelligently choose what to store, and instantly deploy changes to your entire fleet.

Workflows
Company testimonial
Company logo

After integrating Capture into our development process, we've seen a remarkable transformation in both our team's efficiency and the quality of our customer experiences. We've significantly slashed our bug fixing and mobile incident resolution time, allowing us to mitigate problems at a speed we never thought possible. Our apps now run smoother and the overall stability has significantly improved. This is not just a tool; it's been a game-changer for our mobile development.

Patrick Sunday- Director of Infrastructure, Lyft

20,000,000+

Mobile Installs

90%

Mobile Developers using Monthly

500,000,000+

Daily Logs Ingested

Old vs New

Build and scale better

The way we build and deploy software has changed radically in the past decade, but most observability is still stuck in a traditional model that severely limits how developers debug and monitor their apps. New Observability is about building and scaling better apps with unlimited telemetry, instantly deployed changes, and a cost model that
doesn’t break the bank.

Cost Constraints

Traditional Observability
It’s expensive

Whether you pay for storage or per host, Old Observability costs a lot: well past 30% of most teams’ entire infrastructure bill. That’s because you pay for what you generate, instead of paying for what you actually use and get insights from.


New Observability
Doesn’t impose cost constraints

When you only pay for the actual useful data that you store and analyze – not everything you’ve collected – your observability bill isn’t something you need to stress about. New Observability means new, more aligned pricing models.

Log Volume

Traditional Observability
Forces teams to log less

Because Old Observability is so expensive, teams take great care to only log what’s necessary. Logging less means knowing less, and not having the information and context you need when an issue happens.


New Observability
Lets you log everything

Without the cost model constraints of Old Observability, you can log everything. And we mean everything, from device events to network context. If it could conceivably be useful for debugging one day, instrument it.

Device Telemetry

Traditional Observability
Assumes dumb devices

In Old Observability, servers and devices are treated like inanimate objects: they can only send exactly what telemetry you tell them to. Beyond simple filters, there’s nothing to an agent beyond just shipping logs.


New Observability
Builds intelligence into devices

In New Observability, devices are intelligently deciding how to handle telemetry in real time. Local storage, combined with a Ring Buffer, can log everything but only store what you need.

Feedback Cycles

Traditional Observability
Has slow feedback cycles

Without all of the logs they need to deeply understand an issue when it happens, Old Observability forces teams to add new telemetry after the fact. Customers need to wait for a full deployment cycle and enough time to collect new data before your team can actually fix the problem.


New Observability
Has instant feedback cycles

New Observability uses a data / control plane split, and builds intelligence into your devices at the edge. If you need to make a telemetry change, you can do it instantly and deploy immediately without waiting for release cycles or approval.

Mobile

Traditional Observability
Ignores mobile

Mobile lags behind Server when it comes to Old Observability. Mobile developers are stuck using a smashed together medley of crash reporting and device-specific logging frameworks. Many are completely in the dark, and only know about bugs when a user reports one.


New Observability
Gives mobile the focus it deserves

Mobile developers deserve (and need!) best in class observability for their fleet. New Observability gives them feature parity with what backend developers have been enjoying for years on server.

How we do it

We've made telemetry free

We've made telemetry free

Most solutions start streaming data to your expensive backend observability pipelines when you install them. bitdrift’s architecture is based on the idea of selective, retroactive storage: logging everything, but only keeping what you actually need.

Instant exploration at the edge

The core of the bitdrift SDK is an efficient, fixed resource usage log event buffer with flush rules that are configured via real-time APIs.

It has a number of out of the box integrations that automatically record the telemetry of the application, from platform specific data, ux session replay data, to network and resource utilization, as well as ways for users to feed their telemetry into the system.

This data is persisted first through in-memory buffers and then spooled locally to a highly optimized, fixed resource Ring Buffer built to enable high volume, low overhead local telemetry storage. Logging becomes “free” in most cases as the data is only uploaded when the SDK has been configured to do so. bitdrift’s SDK allows you to capture orders of magnitude more telemetry than any other solution, without paying the cost of ingesting, indexing, and storing data.

Fastest way to find and fix problems

Each client has a persistent bi-directional stream connection back to our real time control plane.

It allows you to retrieve that rich buffered data on demand, but only from the clients you need, not your entire fleet. Think of this as making distributed parallel telemetry queries across millions of devices. With a sophisticated targeting engine, you can instantly find and select the exact set of data to ingest, from a single client all the way to millions of devices.

Rules can be updated server side at any time, and are compiled down to Finite State Machines that are deployed and executed on the client against the local buffer. Any data matching those rules are then uploaded through the same persistent connection. So you're paying nothing until you really need the data: Instrument everything, but only upload what you need.

Fastest way to find and fix problems

Best of all, you don’t need an app release to get this data.

Every other solution out there requires an app release to update observability, but bitdrift was built to make as much as possible reconfigurable in real-time. Why wait 2-3 weeks to fix your customers’ problems? With our solution, the control plane instantly deploys targeting rules and configuration updates at the press of a button.You can turn on and off visibility and data collection in seconds, to millions of clients. It's like a mobile development superpower, this big dial you can turn on demand.

Fastest way to find and fix problems

Finally, bitdrift takes all these rich sources of telemetry and displays them in a clean, easy to parse user interface designed to speed up debugging and incident resolution.

We integrate many disparate sources of data, from low level networking calls to privacy aware session replay visualizations (and everything in between!) to provide all the context needed.

Fastest way to find and fix problems

Combine all these, and you have a powerful platform that gives you a real time view into your customers’ actual experiences, finding issues in minutes instead of months.

It frees your engineers from thinking about what to log, and lets them focus on building more and fixing faster. It’s a huge change from the old observability, where you’re paying a huge amount of money for data that never gets looked at.

Features

Supercharge mobile development

Capture by bitdrift comes with a huge amount of built in functionality, right out of the box. Developers can start fixing customer problems immediately, with the best set of mobile development tools on the market. It's like getting 20 developers for free.

Session Timeline

Rich, at a glance view of a customer's entire session, with custom visualizations

UX debug with Session Replay

Bandwidth and privacy conscious session capture, allowing replay of sessions correlated with telemetry

Real-time control plane

Persistent connectivity between every client and bitdrift allows new configs to be sent and applied within seconds

Free local logging

Highly optimized, low overhead local storage effectively provides free and unlimited telemetry on the client

Resource Utilization

Detailed memory, CPU, and battery views, synchronized with a session's timeline

Native Events

Powerful set of built-in out of the box events on iOS and Android the moment the SDK is integrated. Minimal setup needed

Custom Events

Powerful matching and transforms for existing logs. No code needed

Synthetic Metrics

Build cheap metrics off of existing logging, without mobile deploys, and see them in real-time

Performance overhead

Tiny, low overhead SDK with predictable performance

Proven at scale

Deployed to 150 million+ mobile clients, billions of log lines ingested weekly

Integrations

API allows integration with existing crash management solutions as well as the federation of customer data, server or mobile

bdtail
New

Live attach to a set of clients and view telemetry in real-time. A superpower for live support and rapid development

Funnels
New

Build a funnel on the fly with any existing log or signal in your application, and deploy it to millions of devices in seconds

Instant Insights
New

Fleet wide views of your users and their devices

Enterprise Ready

Safeguard credentials, content, and storage

BYOB

Keep strict control over your sensitive data on your own blob storage while bitdrift runs the rest of the system as a full SaaS.

Read About BYOB

SOC 2

bitdrift has partnered with Assurance Lab to achieve the SOC 2 type I compliance certification. Customers can now rest easy that their telemetry data is in good hands and governed by audited industry best practices.

Read About SOC 2

Ready to get started?
Get a demo.