- You have several years of experience, typically 3 to 6, building and operating backend systems under real load. You are strong in TypeScript and Node.js and comfortable with Kubernetes, Terraform, networking, databases, and queues. Experience with Go is useful; willingness to work in it matters more.
- You have strong platform design judgment and approach foundational work with diligence. You can define stable service boundaries and APIs while accounting for data integrity, tenant isolation, backward compatibility, partial failure, and safe rollout.
- Given an underspecified systems problem, you identify the most important invariant, decide where to go deep, and defend what you deliberately leave out. You investigate unfamiliar components and failure modes until you understand the underlying mechanism.
- You treat deployment as the start of ownership. You make systems observable, respond when they fail, and turn incidents into lasting improvements while moving with calm urgency and maintaining a high standard.
- You use AI tools to multiply your output while remaining responsible for the architecture and every change that ships. You share context, ask for input, disagree directly and respectfully, and help other engineers succeed.
This is an experienced individual-contributor role. You should be able to independently investigate an unfamiliar problem, design a solution, ship it, and operate it in production. We generally expect this judgment to come from at least three to six years of full-time experience working on production systems.
Working here
This is an in-office role at Greifswalder Strasse 212 in Berlin. We work together in person because it helps us build trust, develop shared context, and make decisions quickly.
Most engineers start around 8:30. We usually eat lunch together, and dinner is available for people who stay later. Running and gym are part of the routine for many of us.
You need an existing right to work in Germany. We do not currently sponsor visas.
- TypeScript and a growing set of Go services in one Bazel monorepo
- Next.js, React, and Tailwind on the front end
- Node.js services and workers on the back end
- PostgreSQL with Prisma; Redis with BullMQ
- Protobuf and gRPC for service contracts
- Kubernetes across GCP, AWS, Azure, and on-premises deployments
- Terraform and Terragrunt for infrastructure orchestration
- You should be familiar with most of this. We trust you to pick up the rest quickly.
- We operate with high trust and autonomy in squads of 3 to 4 engineers. A squad owns its roadmap, prioritization, technical decisions, and operation in production. Engineers are expected to find the context they need, ask for input when it improves the outcome, and move work forward without waiting for every next step to be assigned.
- We align asynchronously before scheduling a meeting. Product requirement documents (PRDs) define the user problem, intended outcome, and constraints. Design documents make architectural boundaries, tradeoffs, failure modes, migrations, and rollouts explicit. People read and challenge the thinking asynchronously; once the context is shared, a short in-office discussion or whiteboard session usually resolves the remaining questions quickly.
- We optimize for leverage. Engineers choose the AI tools that work for them, supported by clear ticket context, focused branches, automated tests, and AI review before human review. We also invest in observability, migration tooling, automated recovery, and runbooks so recurring product maintenance does not depend on someone remembering a manual step.
- The engineer who ships a change owns it in production. If something breaks, you lead the fix.
