Software Development Engineer I (SDE-I) —Backend / Java

Design systems, not just services. Own the high-level and low-level design for your area service boundaries, data models, API contracts, and the event flows that connect them. Make and defend the trade-offs (consistency vs. availability, sync vs. async, build vs. reuse).

Build for scale. Design features that hold up as traffic, data, and the fleet grow partitioning, caching, asynchronous processing, and back-pressure where they’re needed, and simplicity everywhere else.

Engineer for resilience and reliability. Build services that degrade gracefully: timeouts, retries with backoff, circuit breakers, idempotency, and dead-letter handling. Define SLOs, instruments for them, and own the result in production.

Drive event-driven architecture. Design Kafka-based flows with clear ownership of delivery semantics, ordering, and failure recovery.

Own data design. Model and evolve PostgreSQL schemas for correctness and performance; reason about indexing, query plans, transactions, and safe online migrations.

Operate what you build. Set up metrics, structured logging, tracing, and alerting; lead debugging of live issues and drive incidents to root cause and prevention.

Raise the bar in code review. Review pull requests with rigor, mentor junior engineers, and improve the standards and patterns the team builds on.

Use AI tools well. Apply AI coding/review tools across the workflow to move faster while staying fu- lly accountable for the quality and correctness of what ships.

Partner across functions. Work with product and other engineering teams to scope problems, break them into shippable increments, and deliver them with honest estimates and clear communication.

1-3 years designing, building, and operating production backend systems.

A track record of system design at scale – you can take an open-ended problem to a clear architecture and explain why, covering availability, consistency, failure modes, and growth.

Strong Java fundamentals — concurrency, the JVM, and writing code that’s correct under load — plus deep, hands-on Spring Boot / Spring experience.

PostgreSQL (or strong relational DB) expertise: schema design, query tuning, transactions, and safe migrations.

Production experience with Apache Kafka or a comparable streaming/messaging system, including how to make event pipelines reliable.

Experience designing REST APIs and building in a microservices architecture, with a real sense for resilience patterns and observability.

Hands-on experience using AI development tools (Claude / Claude Code, GitHub Copilot, or similar) in day-to-day engineering, with good judgment about where they help.

A daily code-review practice and the maturity to both give and receive feedback well.

Clear communication and the ability to drive work to completion independently.

Thrives in a fast-paced environment – ships quickly without cutting corners, and stays effective when priorities shift.

Microservices in Spring Boot, PostgreSQL, and Kafka — observability and tests are part of “done,” not an afterthought.

Design is discussed before it’s built; pull-request reviews gate every change, and humans own the call even when tooling assists.

AI is part of the toolchain end to end — we expect engineers to use it well and own the outcome.

We move fast — short cycles, frequent releases, and high ownership — while keeping quality and operability non-negotiable.

We value clear thinking, honest estimates, and systems the next engineer can understand and operate.

The reliability, resilience, and scalability of the systems you own.

The quality of your designs and how well they hold up as the product grows.

The impact of your code reviews and mentorship on the team.

Your ability to turn an ambiguous, large-scale problem into a correct, well-operated solution.