V

VendNovation

·Today

Senior .net engineer, payment systems integration

Apply now

Location

remote, United States

Commitment

Full Time

Level

Senior (5+ years)

Required skills

OSOSSProgramming LanguagesFull Stack Framework

Job Description

Senior .NET Engineer, Payment Systems Integration

VendNovation · Client Team

The short version More than 2,500 unattended vending machines are in the field today, and the program is growing fast. Each machine is a $25,000 piece of hardware with a Windows PC inside. Our enterprise customer is a household-name global brand, and VendNovation has been its lead software provider since day one. We’re adding a new payment provider to the software that runs inside those machines. The team knows payments and has integrated providers before. What we’re missing is a senior engineer with the time to own this one, so this seat exists to do one integration and do it right.

The happy path is the easy part. The hard part is everything a customer, a network, or a power cord can do to a transaction halfway through it. When one of those goes wrong, somebody gets charged twice.

What you’d actually be dealing with A customer pushes a card in at the exact moment they hit Back, then pulls it out. Sometimes that’s an accident, and sometimes they’re doing it on purpose to see what breaks. The flow works like a gas pump: authorize, vend, capture. Vends don’t always go as planned, so the capture has to match what the customer actually received. Someone pulls the PC’s power cord partway through a transaction. When the machine boots back up, the payment state still has to make sense. The payment device gets enabled and disabled in rapid succession while people hammer the touchscreen. The partner service can be slow, connections drop, messages arrive twice, and events show up out of order. The refund workflows only work if the authorization data you recorded is complete and correct. The partner’s API documentation doesn’t always match its behavior, so some of that behavior has to be confirmed by reproducing it. If that list reads as a headache, this isn’t your role. If you started sketching a state diagram, keep going.

Why engineers take this job The problem is hard, and it has edges. It’s concurrency, sequencing, and failure recovery with real money at stake, in a clearly scoped project with a finish line. The foundation is already built. An established device-integration architecture already covers lifecycle, state, diagnostics, and testing, so you won’t be inventing the framework mid-project. You never touch card data. A payment middleware layer talks to the card reader, which keeps PCI scope small. Your attention goes to correctness rather than EMV internals. It’s bound to hardware. You’ll work with physical machines, real payment devices, and edge cases that only show up when thousands of strangers use the product unsupervised. Stability without bureaucracy. VendNovation is 25 years old and about 50 people. It’s large enough that you’re not watching for a missed payroll, and small enough that there’s no approval chain to fight.

Remote. You can work from anywhere in the US, with no relocation and no hybrid schedule. Modern tooling, used seriously. The client team works with Claude and agentic tooling as its default way of building. Claude writes a lot of the code, and you’re accountable for what that code charges a customer’s card.

What you’ll own The .NET components that connect the machine’s client software to the new payment platform and its payment device. Payment flows end to end: pre-authorization, capture, void, cancellation, and recovery from interrupted transactions. State transitions that are explicit and traceable, and that stay correct through retries, timeouts, duplicate or stale responses, re-entrant commands, and process restarts. The transaction data that the refund and customer-support workflows depend on. Logging, telemetry, and transaction correlation detailed enough to reconstruct exactly what happened after the fact. Automated tests plus a simulator or test harness, so the failure paths can be exercised without a payment device on your desk. The technical relationship with the payment partner: clarifying API behavior, reproducing defects, and validating fixes. Coordination with the engineers who own the client architecture, the vending transaction flow, and refunds.

What you’ll bring 7+ years building production software in C# and .NET. Experience with integrations where a duplicate or out-of-order event causes a financial or customer-facing error. Strong command of async programming, concurrency, cancellation, timeouts, and state management in .NET. The habit of working out failure sequences before they happen, including race conditions, re-entrancy, command ordering, and recovery after a crash. Experience integrating third-party APIs or SDKs and debugging across application, device, network, and partner boundaries. The discipline to build inside an established architecture without routing around it. Strong automated testing skills, including tests for failure conditions, timing-sensitive behavior, and state recovery. Real use of Claude or similar agentic tools for substantive engineering work, plus the judgment to evaluate what they produce. Clear written communication, because much of this job is explaining a sequence of events precisely. Payments experience helps, but what we’re really hiring for is how you think about sequences and failure. You don’t need a cloud or web background, since this is client-side software running on Windows. The background that fits best: you’ve integrated cash-handling or payment hardware into Windows-based ATMs or kiosks, or you’ve integrated payments into another vending platform. If that’s you, you’ll recognize this job on day one.

What success looks like First 30 days You can explain how the device-integration architecture handles lifecycle, state, and recovery, and you’ve mapped the new partner’s API onto it. You’ve written up the transaction sequences most likely to go wrong, and the team agrees it’s the right list. A first version of a simulator or harness lets payment behavior run without hardware in the loop. By 3 months Pre-authorization, capture, void, and recovery are implemented and under test. Automated tests cover rapid input, duplicate commands, retries, timeouts, and process restarts, and they run on every change. Every payment state transition is logged and correlated, so any single transaction can be traced end to end. Defects on the partner’s side are reproduced, documented, and in the partner’s hands with evidence. By 6 months The integration is live in the field and holding up under real customers. Duplicate captures and orphaned authorizations get caught by tests before any customer reports one. Refund workflows run cleanly on the data you record. The documentation and tests are thorough enough that the team can own the integration after you roll off, without needing to call you.

The details Location: Remote, United States. Team: The Client Team, which builds the software running inside the machines. Our cloud platform is a separate team.

Ready to join the team?

Apply now

Similar Jobs: