Vacancies – Recruitment – IT professionals – IT hire

What you'll do

Own one or more meaningful product domains (think: AI agents, payments, public API, real-time engine, etc.) from architecture through rollout
Drive system design decisions on our AWS serverless stack: data model, API shape, multi-tenant isolation, performance, observability
Write production code across the stack: backend (Lambda, AppSync, GraphQL, Postgres) and frontend (React, MUI)
Build with AI as a first-class material: LLMs, prompt engineering, RAG, agentic workflows. Push us toward smarter product and smarter ways of working
Raise the bar through code reviews, RFCs, ExecPlans, and the standards you set by example

5+ years building production software for customers.
Strong architectural decision-making and system design. You've owned non-trivial systems through multiple releases
Track record of driving complex, end-to-end features with visible product impact, not just refactors or incremental improvements
Working fluency with AI technologies: integrating LLMs into real products, with hands-on experience in prompt engineering, vector databases, and RAG
Product sensibility: you care about UX, speed, and polish, and you push back when something doesn't feel right
Comfortable working without heavy PM overhead; you can shape the problem, not just implement a solution
High ownership mentality. Self-directed, full-lifecycle builder who takes a feature from idea to shipped
Excellent written communication. Most of our work happens async, in writing (PRs, RFCs, ExecPlans, Slack threads)

Scaling GraphQL APIs with AppSync or Apollo
Observability practices in AWS/Sentry (CloudWatch, metrics, alarms, structured logging)
Shipping B2B SaaS that handles sensitive data: payments, PII, multi-tenant isolation
Building agentic systems or production AI features beyond a basic LLM call
Experience at a startup or a company with a genuinely high engineering bar

You aren't expected to have shipped everything below, but you should be excited to work close to most of it.

Language: TypeScript end-to-end
Frontend: React, Material UI, Vite, GraphQL clients
Backend: Node.js Lambdas, AppSync (GraphQL), a Hono-based REST Public API, EventBridge, SQS, DynamoDB
Data: Postgres (Aurora), tsvector-based full-text search, real-time sync engine over WebSockets
Infra & Observability: AWS, CDK, Sentry, CloudWatch
Tooling: pnpm + Nx monorepo, Vitest, Playwright, Linear, Slack, Notion, Claude Code

Minimum bureaucracy, direct access to leadership. No meeting overhead for its own sake. You'll work directly with the Head of Engineering and other leaders on what matters. The rest of the time is for building.
Six-week cycles. We plan and ship in six-week cycles, with a cooldown between. Long enough to do something real, short enough to course-correct.
Engineers own domains end-to-end. From architecture through rollout and ongoing health. No throwing things over the wall.
We reprioritize when the business and our customers need us to. Plans are a tool, not a contract. If a partner problem or a market shift changes what matters most, we move.
Code improvements are encouraged, not negotiated. If you see something worth fixing inside your domain, fix it. You don't need a ticket to clean up as you go.
Async-first, writing-first. Most decisions happen in PRs, RFCs, ExecPlans, and Slack threads. Meetings are for things writing can't do.
Small team, high trust, high bar. You'll have real autonomy and real accountability. We assume good intent and direct communication.
AI-native by default. We use AI tooling (Claude Code, Cursor, Linear, etc.) across the team. We expect every engineer to be fluent and opinionated about where it helps and where it doesn't.