Role: Senior Software Engineer

Department: Software Engineering

Reports To: CTO

Compensation Range: $160,000 - $200,000 per year

About this Role

The simplicity our Bellwether customers feel - consistent roasts anyone on staff can run, green coffee sourced and delivered to their door - is technology. That's the magic we build, and it spans an unusually wide surface: a green-coffee marketplace that handles sourcing and fulfillment, a cloud fleet-management platform, software running on the roaster itself, over-the-air update infrastructure, and the web and mobile apps our customers and team use every day. We build the connected machines and the platform that make it all possible - real roasters roasting real coffee in cafés, grocers, and roasteries across the world.

Job Location

The role requires on-site presence at Bellwether's Berkeley HQ.

Why this Role

That's a lot of surface for one engineering team - and that's the appeal, not a problem to specialize away. One change can travel from a Spanner schema migration to a gRPC API to firmware on a device on a café counter.

We're looking for a senior engineer who is energized - not intimidated - by that breadth, and who wants ownership across the whole stack rather than a narrow lane.

A note on leveling: "Senior" here isn't a rung on a ladder. We don't run a staff / senior-staff / principal hierarchy - we're a small team of empowered individuals, and we tune the scope and the compensation of each role to the experience a candidate actually brings. What we care about is whether you measure progress by the problems you own and the autonomy to act on them, rather than by a level or a place in a reporting chain.

Primary Responsibilities - What you'll work on

You'll move across the system as the work demands. In a given month you might:

• Build fleet-management services and APIs in Go, backed by Spanner, exposed over gRPC/protobuf, deployed to GKE with Terraform-managed GCP infrastructure.
• Improve the on-device roaster application (TypeScript backend + frontend + simulator) and the Go firmware control daemon that talks to the hardware.
• Harden our over-the-air update pipeline and Raspberry Pi OS image builds - the path that gets new code safely onto physical machines in the field.
• Build the green-coffee marketplace that connects customers to sourcing and fulfillment - the commerce and inventory backbone that makes "a complete program from day one" real.
• Ship features across our SvelteKit web, Swift (iOS), and Kotlin (Android) apps spanning customer, maintenance, and operations tiers.
• Diagnose production fleet behavior using our BigQuery data lake - turning a field report into a root cause.

You won't do all of this on day one. But over time, you'll be trusted with all of it

Qualifications - What we're looking for

• End-to-end ownership. You've shipped and operated production systems yourself, and you're comfortable being the person who follows a problem wherever it leads - backend, device, or UI.
• Strong systems fundamentals. Solid in Go or TypeScript, with the range to pick up the rest of our stack - Swift, Kotlin, embedded C - as the work calls for it. Comfortable with distributed systems, APIs, and relational/strongly-consistent databases.
• You build with agentic coding tools as a core part of how you work. You use tools like Claude Code, Codex, or Cursor as a daily force-multiplier, and just as important, you have a clear point of view on where they accelerate you and where they need a tight leash. You can describe non-trivial work you've shipped with agentic tooling and how you verified it was correct. This is a genuine requirement for us, not a nice-to-have.
• Judgement about correctness. We touch physical hardware and customer data, so you care about testing, schema discipline, and not breaking the fleet - without grinding velocity to a halt.
• Pragmatic communicator. You write clearly, scope sensibly, and make good calls when requirements are fuzzy.

• You are authorized to work in the U.S. without Visa Sponsorship

Nice to have Skills

• Embedded / IoT, OTA updates, or fleet-management experience
• GCP, Kubernetes, or Terraform in production
• gRPC/protobuf-based service design
• Experience with hardware-adjacent software, or a personal interest in coffee

How we work

We're an AI-native engineering team: agentic tooling is woven into our daily workflow, and we expect engineers to keep getting sharper at using it well. We pair that with old-fashioned engineering discipline - canonical schemas, real tests, careful rollouts to physical devices. And there are real roasters in the building: the machine your code controls is one you can walk up to, and the coffee it makes is something you can taste. Small team, high trust, real autonomy, and the shortest path imaginable from a commit to a cup.