Software Engineer - Functions (Compute)

Senior-level backend or systems engineers with at least five years of experience, strong Rust and TypeScript skills, and expertise in compute runtimes, infrastructure, and distributed systems are best suited for this role.

They should be familiar with Firecracker microVMs, V8 Isolates, Deno, Kubernetes, cloud platforms, observability, OpenTelemetry, and operating reliable infrastructure at scale.

The role involves architecting and optimizing compute platforms, building runtime features and developer tooling, integrating infrastructure with databases and services, contributing to open source, and participating in production on-call rotations.

How would you design a Firecracker-based microVM platform for securely running untrusted user workloads at global scale?

I would isolate each workload in a minimal microVM with strict resource limits, network policies, and lifecycle controls. The platform would manage image preparation, snapshotting, placement, startup, teardown, and regional failover while keeping the execution API simple for developers.

What techniques would you use to reduce cold-start latency in a microVM-based runtime?

I would use optimized kernel and root filesystem images, prebuilt snapshots, lazy loading, warm pools, and parallel initialization. Metrics should separate scheduling, image retrieval, VM boot, runtime initialization, and user-code startup so each stage can be optimized independently.

How would you implement observability for Compute using OpenTelemetry?

I would instrument request routing, scheduling, VM lifecycle events, runtime execution, storage, and downstream Supabase integrations with traces, metrics, and structured logs. Trace context should propagate from the public request through the edge, microVM, and services such as Postgres or Storage.

How would you safely execute TypeScript workloads using Deno or V8-based isolation?

I would combine OS-level isolation from Firecracker with runtime-level permissions, restricting filesystem, network, subprocess, and environment access. Resource quotas, execution timeouts, dependency controls, and defense-in-depth validation are essential because no single sandbox boundary should be trusted alone.

How would you design scheduling for functions and background tasks across multiple regions?

I would use durable task state, idempotent execution semantics, leases with expiration, and a scheduler that accounts for region, capacity, latency, and data locality. Retries should use exponential backoff and dead-letter handling, while duplicate execution should be safe through idempotency keys.

How would you support WebSocket connections and streaming responses in an edge compute platform?

The system needs connection-aware routing, long-lived resource accounting, heartbeat and timeout management, and graceful migration or termination behavior. Backpressure must be enforced across the user function, network buffers, and downstream services to prevent slow clients from exhausting capacity.

What Rust design considerations are important when building the Compute control plane?

I would use explicit ownership and cancellation boundaries, async tasks with bounded concurrency, typed errors, and careful timeout propagation. Shared state should be minimized, while resource cleanup must be reliable through structured concurrency and RAII-based guards.

How would you integrate Compute with Supabase Auth, Postgres, Storage, and Realtime?

I would standardize identity propagation, short-lived credentials, tenant isolation, and observability across every integration. Connection pooling, regional data placement, retries, and clear consistency guarantees are important to avoid turning downstream services into latency or reliability bottlenecks.

How would you investigate a sudden increase in production function latency?

I would first use dashboards and distributed traces to determine whether the issue comes from routing, scheduling, cold starts, VM capacity, user code, or a dependency. I would correlate latency with deployment versions, regions, resource usage, error rates, and saturation before applying mitigation such as shifting traffic or increasing warm capacity.

How would you improve local development and production parity through the Supabase CLI?

The CLI should provide reproducible local runtimes, matching APIs and permissions, realistic logging, local tracing, and easy inspection of function lifecycle events. DevTools integration and clear emulation limits would help developers debug locally while understanding which behaviors depend on production infrastructure.

Supabase is a developer-first Postgres platform hiring a remote, global Software Engineer to build its Compute platform powered by Firecracker microVMs. You’ll architect reliable, observable infrastructure, improve runtimes and developer tooling, integrate with Auth, Postgres, Storage, and Realtime, and contribute to open-source projects while participating in on-call. The stack includes Rust, TypeScript, Firecracker, Deno, OpenTelemetry, Kubernetes, AWS, and Redis; compensation is not disclosed. Apply to work asynchronously with a globally distributed team, shape next-generation edge compute, and receive equity, generous benefits, professional development support, and an annual tech allowance.