Staff Software Engineer, Full Stack (Agentic Payment)

About Sapiom

Sapiom is payment infrastructure for AI companies and agents. One integration lets an agent pay on behalf of a person or a business, with permissions, protected card credentials, and spending rules built in.
Agents can think now, and increasingly they can act. What they can’t do is spend. The rails underneath assume a person at the keyboard, so teams fall back on closed catalogs, cards and API keys pasted into config, or a human approving every purchase. We’re removing that constraint. A customer connects a card and grants a named agent permission without leaving your product. They set the limits — per purchase, per merchant, approval required or not. The agent buys inside those limits across browser checkout, payment protocols, and APIs. Card details never enter the conversation, and every purchase leaves a record from approval through merchant confirmation.
The work spans the whole path a purchase takes: connecting a customer and their agent, vaulting the card, establishing agent identity, enforcing the rules, moving the payment, and making the outcome legible afterward. Card issuing, voice-initiated payments, payment recovery, and insurance are all part of where this goes.
We have assembled a team with deep infrastructure and payments DNA. Our founder ran payments engineering at Shopify for five years and built an autonomous consumer agent company before that. We raised a $35M Series A led by Dragonfly in August, bringing us to $50M total. Accel led our seed; Menlo Ventures and Anthropic are also behind us.

Agents are starting to buy things on their own, and the rails underneath all assume a person at the keyboard. Letting an agent complete a purchase inside limits its owner actually set, and keeping proof of what was agreed, is the company.

The first version of that ships before you'd start. Almost everything that turns it into something customers can depend on is still ahead, and the team works those problems in parallel rather than one at a time. You'd own one of them.

Payments is unforgiving in a way most product work isn't. A purchase either moves money or it doesn't. A record either holds up six months later when someone disputes a charge, or it's worthless. We'd like someone who finds that interesting.

This is a staff role. You'd set the design for a large piece of this, at thirty people, while it's still deciding-shaped.

Limits and authority. How much latitude an owner hands an agent, and how that gets enforced before money moves rather than explained afterwards. Most of these decisions are still open.

Completing the purchase. Checkout is where this gets unglamorous. Every merchant behaves differently, totals move, and plenty of steps still expect a human. Making that reliable across a long tail of them is a multi-quarter problem.

What happens when it goes wrong. A payment that goes quiet is the hardest case in the domain. The system has to work out what actually happened before it does anything else, and never charge someone twice.

Proof. A versioned record of what a buyer saw and agreed to, still legible months later when someone disputes it. Unglamorous, and the thing the rest of it rests on.

The surface customers build on. A public API and the tools an agent calls. Designing a contract a model uses correctly is its own discipline.

• You have 8+ years building production software, several of them in payments, money movement, or financial infrastructure. We're hiring for depth in the domain.

• You've owned architecture from first principles — set the design, defended it, and lived with what it cost.

• You've worked somewhere being wrong was expensive, and you design for failure up front: idempotency, retries, reconciliation against a number someone else is also computing.

• You have real range across the stack. Strong TypeScript, and you build the interface on top of your own system instead of handing that off.

• You've run a multi-month project from a problem statement rather than a spec, and other engineers built on what you shipped.

• You use AI tools in your own engineering workflow.

Nice to have: card issuing, tokenization, or PCI scope; checkout integrations at depth; browser automation or request interception; something you shipped that an LLM calls as a tool; early-stage companies where you set the architecture rather than inherited it.

A recruiter screen, then a loop of roughly three hours: a hands-on AI project, a project deep dive, and a conversation with our founder.

Everyone on our engineering team carries the title Member of Technical Staff internally.