Senior Software Engineer, Rust

About Ditto

Ditto is redefining how data moves at the edge. Our mission is to make it seamless for developers to build resilient, real‑time applications, regardless of network conditions. Whether you're in a stadium, airplane, or remote military base, Ditto's peer‑to‑peer sync engine ensures devices stay connected and data stays consistent, even without internet. With more than $145 million in funding and trusted by organizations like Chick‑fil‑A, Delta Airlines, and the U.S. military, Ditto powers mission‑critical experiences across aviation, retail, travel, hospitality, defense, and more.

As a globally distributed, fast‑growing startup, we’re committed to building a diverse and inclusive team that reflects the wide range of perspectives needed to solve the world’s hardest connectivity problems.

Ditto's SDK runs on thousands of devices across iOS, Android, desktop, and embedded platforms — from restaurant POS terminals to military radios. The Rust core is the engine, consumed via FFI across all of them. Once it ships, we have limited visibility into how it behaves in our customers' environments. When something goes wrong, we need to understand what happened — often on devices we can’t access, on networks we don’t control, running workloads we didn’t anticipate.

You’ll own the observability story for Ditto's SDK. That means designing and building the telemetry pipeline that runs inside the Rust core: what we instrument, how we collect and buffer it locally, how we get it off the device, and how we make it useful — both for our engineering team diagnosing issues and for our customers understanding how Ditto is performing in their applications.

This isn’t configuring Datadog dashboards. You'll be designing systems that run on constrained hardware with intermittent connectivity, where every byte of overhead matters and the observability system must never degrade the SDK's core functionality. You'll think about bounded buffers on devices with 2 GB of RAM, support bundles that help our support engineers resolve issues in hours instead of days, and remote telemetry that gives us fleet‑level visibility across hundreds of customer deployments.

• SDK Observability Pipeline — Design, build, and maintain the client‑side telemetry system in the Rust core. Metrics, structured logging, and tracing that work across all platforms the SDK targets, with configurable verbosity, sampling, and export.
• Support Bundles — Evolve our current log bundle system into comprehensive support bundles that capture device state, recent telemetry, configuration, and diagnostic metadata — giving our support engineers (and customers) the context they need to resolve issues quickly.
• Logging System Performance — Reduce the I/O and compute overhead of our current logging infrastructure. The SDK's observability should be near‑invisible to the host application's performance.
• Rust SDK Ownership — Own feature development and customer support for our Rust SDK, including direct engagement with customers debugging production integration issues.

• Systems‑level Rust experience (3+ years) — You've built production‑grade Rust libraries or systems. You're comfortable with unsafe, FFI boundaries, async runtimes, and reasoning about memory layouts and performance at the microsecond level.
• Observability and telemetry design experience — You've designed or significantly contributed to instrumentation, logging, metrics, or tracing systems. You understand the tradeoffs between signal granularity and overhead, and you've thought about what makes telemetry useful, not just voluminous. Experience with Open Telemetry is a strong plus.
• Library/SDK development mindset — You've built software that other developers consume as a dependency. You think about API design, backward compatibility, developer experience, and the principle that your library is a guest in someone else’s application.
• Cross‑platform and FFI fluency — The Rust core ships via FFI to Swift, Kotlin, C#, JavaScript, and more. You need to be comfortable working across language boundaries and understanding how your Rust code behaves…