Senior Backend Engineer — First Engineering Hire

We're building a global payments platform — API-first, modeled after Stripe — and hiring our first engineer. The founder built the entire product with AI tooling (Claude Code, Cursor). The platform is live: full merchant API, dashboards, payment orchestration, documentation, CI/CD. Now we need a senior engineer to own production reliability, code quality, and infrastructure decisions as real merchants onboard and real money moves.

This is not a "write CRUD endpoints" role. AI generates the majority of the code. Your job is to review it, catch the edge cases that cause double-charges or race conditions, ensure zero-downtime migrations, and be the person who knows exactly what to do when payments break at 2 AM.

You'll inherit a mature codebase and a disciplined engineering process — not a blank slate — and extend both as the team grows.

What You'll Do

• Review and harden AI-generated backend code daily — mandatory type-check gates, no empty catch blocks, no parseFloat on monetary values (everything is integer cents)
• Own production monitoring, alerting, and incident response — Sentry, structured logging (zerolog), on-call
• Manage database performance — query optimization, migration safety, connection pooling on Neon serverless (dual-driver: HTTP reads, WebSocket transactions)
• Operate and upgrade Hyperswitch — our open-source payment orchestrator running on Docker/Railway; you'll manage the service lifecycle and eventually own its Kubernetes migration
• Make infrastructure decisions — scaling strategy, service boundaries, deployment pipeline improvements
• Ensure payment flow correctness — idempotency, state machine transitions, settlement reconciliation, ledger integrity
• Own secrets and environment management — Doppler sync across Railway, Vercel, and AWS
• Keep engineering documentation current — architecture decisions, runbooks, API contracts live in Outline and must stay in sync with the code

Tech Stack

API Server: TypeScript, Hono.js v4.6+, Zod validation, @hono/zod-openapi

ORM / Database: Drizzle ORM, PostgreSQL 16 (Neon serverless — dual-driver: HTTP reads, WebSocket transactions)

API Gateway: Go 1.22+, Upstash Redis rate limiting, zerolog structured logging

Payment Orchestration: Hyperswitch (Rust, Docker) with Stripe connector

Workflow Engine: Temporal Cloud — webhook delivery, payment sagas, retry logic

Frontends: Next.js 15, Tailwind v4, Clerk auth, shadcn/ui

Infrastructure: SST Ion, Vercel, Railway, AWS ECS Fargate, GitHub Actions CI/CD

Edge / Async: Cloudflare Workers, Cloudflare R2, Cloudflare Queues

Secrets: Doppler (synced to Vercel, Railway, AWS Secrets Manager)

Monitoring: Sentry (Node.js + Go)

Cache: Redis (Upstash)

Monorepo: pnpm workspaces, git worktrees

Required

• 5+ years backend engineering
• TypeScript — advanced: you can read Hono.js routes, Drizzle schemas, and Zod validators without ramp-up time
• PostgreSQL — deep: query tuning, transaction isolation levels, zero-downtime migrations, connection pooling
• Production operations — you've been on-call, triaged multi-service incidents, built monitoring and alerting from scratch
• Docker — comfortable managing and debugging containerized services
• CI/CD — GitHub Actions or equivalent; you understand what happens when a deploy breaks
• Monorepo experience — pnpm workspaces or equivalent; you know how to work cleanly across package boundaries
• Comfortable reviewing AI-generated code — not just "using Copilot," but auditing code that AI wrote from spec to production: catching type gaps, missing error paths, incorrect assumptions about external APIs

Strong Bonus

• Go — our API gateway is Go; you don't need to be expert but readable is the bar
• Payments / fintech domain — PSP integrations, idempotency patterns, ledger design, reconciliation
• Temporal or any workflow engine — Temporal Cloud is core to our async flows
• Kubernetes — Hyperswitch migration to ECS/K8s is on the roadmap
• Cloudflare Workers — we're expanding edge usage
• Hyperswitch or any open-source payment orchestrator experience

Not Required

• Degree or certifications
• FAANG pedigree
• Having used this exact stack before — a strong engineer ramps fast

Your First 30 / 60 / 90 Days

30 days: Get the full platform running locally. Read the codebase end to end. Shadow three production deploys. Own your first incident (or near-miss). Identify the top three reliability gaps.

60 days: Own production monitoring end to end — alerting, dashboards, runbooks. Perform your first schema migration under load. Improve the CI pipeline in at least one meaningful way.

90 days: You're the person who reviews every significant backend change before it ships. You've made at least one infrastructure decision that will outlast your tenure. You're setting the engineering standards the next hire will follow.

What Makes This Role Different

You're engineer #1, not engineer #50. There's no existing engineering culture to inherit — you build it. That means your judgment on code quality, incident response, and system design becomes the default.

The AI workflow is real, not a talking point. Claude Code runs with mandatory checkpoints: type-check gates before every commit, PROGRESS.md files tracking every agent's work, multi-agent sessions across git worktrees. You'll be the human in that loop — reviewing diffs that span six files written in parallel by subagents, catching the edge cases the model didn't see.

The work is consequential. Payments are unforgiving. A bug in an idempotency key means a merchant gets charged twice. A botched migration means downtime. You'll write the runbooks, own the alerts, and be accountable when things break — because you're also the one who prevented most of it.

No process overhead. No sprint ceremonies, no tickets, no design-by-committee. You see a problem, you fix it. That's liberating and demanding in equal measure.

Equity that means something. First engineering hire at an early-stage payments company. Generous allocation, standard vesting, priced at the ground floor.

What We're Not

We won't pretend this is easy. You're joining a two-person team (founder + you) with real merchants and real money on the platform. There's no senior engineer above you to escalate to. If you need extensive mentorship, a large team to distribute risk across, or a mature engineering org to learn from, this isn't the right fit yet.

If you want maximum ownership, minimum bureaucracy, and to build something that ships — this is it.