Technical Support Engineer (Java)

Why this role exists

Our products are deep and technical, and our customers need someone who can pick up a broken transaction, reason about where it went wrong across our services and the rails beneath them, and actually fix it — not file a ticket and wait.

That's what this role is. You sit inside Product Engineering, not in a separate support silo. You're customer-facing, you debug in the real codebase, and you can merge fixes to production. Your job is to collapse the time between "a customer is blocked" and "the customer is unblocked" — and, over time, to make the class of problem stop recurring.

This is a resolution role, not a triage role. The bar is set accordingly: we hire people we trust with production access and code review, because that's what the job requires.

What you'll do

• Own resolution for customer issues end to end — reproduce, diagnose across our services and upstream dependencies (RTAs, TSPs, payment and KYC providers), and ship the fix.

• Merge to production under real guardrails — write the fix, get it reviewed, deploy it with tests and a rollback plan. Fixing hot under time pressure is exactly when discipline matters most, and we hold you to it.

• Protect the operational continuity of your area for every customer. Each support engineer owns a functional domain — Orders, Payments, and so on — and keeps it running smoothly: an Orders engineer ensures units move cleanly, a Payments engineer ensures money moves. When a bug threatens that day-to-day operation, you're the person who keeps it from becoming an incident.

• Triage cleanly and route what isn't yours. Some tickets are genuine bugs (you own these); some are "the integration behaves unexpectedly" or "we need a capability that doesn't exist" (you route these to the right owner) — always without the customer feeling dropped.

• Communicate with technical customers as a peer — clear status, honest timelines, and the confidence that comes from someone who understands the system, not someone reading from a script.

• Drive down recurring issues, not just close tickets. Spot the pattern behind repeated failures and either fix the root cause or make the case for the engineering investment that will. You'll partner with TPMs on operational health metrics (failure rates, latency, recurring-issue rates) for the areas you support.

What makes this role different

Most "support engineer" roles are a queue and a knowledge base. This one is genuine engineering with a customer-driven backlog. You'll write real code against a real production system, and the work you do is visible to the people who care most about the product. That proximity — to the code, to the customers, to the failure modes — is also the fastest way to learn how the whole system actually behaves under load.

What we're looking for

Required

• Strong debugging and systems-reasoning ability — you can hold a distributed flow in your head, form hypotheses, and narrow down where it broke.

• Production-grade engineering in Java — you can read an unfamiliar codebase, write a correct fix, and understand the blast radius of a change.

• Comfort with the full production discipline: code review, testing, safe deploys, rollbacks.

• Excellent written and verbal communication — the people you deal with on a customer's side might be engineers, PMs, compliance, or others, and you can articulate a technical problem in terms each of them understands, staying clear and calm under pressure.

• Sound judgment about escalation — knowing what to fix yourself, what to route, and when to pull the alarm.

• 3–6 years of experience, including hands-on ownership of production systems — you've shipped fixes to prod and dealt with live issues, not just built features.

Strongly preferred

• Experience with production incidents, on-call, or customer-facing debugging.

• Familiarity with SQL / PostgreSQL for investigating data-level issues.

• Exposure to fintech, payments, or regulated systems — or a demonstrated ability to get up to speed on complex domain rules quickly.

• Understanding of API-driven, multi-tenant systems.

We are not looking for

• Someone who wants to write only new features and never touch a customer.

• Someone who wants to only talk to customers and never touch code. The whole point of this role is that it's both.

What you can expect from us

• Production access and the trust that comes with it, from day one after ramp-up.

• Direct line of sight to customers, founders, and the engineering leadership — your work is not buried.

Apply to this job