TRPD-26-04980

Senior Embedded Software Engineer (Payments/EMV, C++17)

Senior Embedded Software Engineer needed to build high-performance, deterministic and secure firmware for next-generation payment hardware. The role focuses on EMV Contact/Contactless (L1/L2) kernel development, zero-allocation APDU pipelines, modern C++17 driver architecture for common peripherals, and deep debugging using IEEE-ISTO/Nexus tracing. You will also own cross-compilation and CI/CD automation, run EMV regression in QEMU/SIL, and use sanitizers (ASan/TSan/UBSan) to harden firmware quality for certification-grade transactional security.

Apply for this role See all roles

Position summary

Location: India
Workplace: Hybrid
Employment: Full Time
Experience: Minimum 5 years and Maximum 10 years

Apply now

Role overview

Why This Role Matters.

Your Impact

Deliver Enterprise Value

Help organisations solve complex business problems through modern technology, consulting expertise and measurable outcomes.

Collaboration

Work Across Teams

Collaborate with consultants, architects, engineers and client stakeholders throughout the project lifecycle.

Growth

Learn Continuously

Gain exposure to enterprise technologies, certifications, mentoring and real-world project experience.

Career Path

Grow With Ubique

Build a long-term consulting career with opportunities to take on greater responsibility and leadership over time.

Responsibilities

What You'll Be Doing.

Every role at Ubique contributes directly to solving meaningful business challenges for our clients.

EMV Protocol Implementation & Compliance: Design, optimize, and maintain EMV Contact (L1/L2) and Contactless kernels. Implement highly secure, zero-allocation APDU parsing pipelines and cryptographic wrappers that comply with strict payment network certifications.

Modern Driver Architecture: Design and maintain peripheral drivers (SPI, I2C, UART, CAN, DMA, NFC/RFID interfaces) utilizing C++17 compile-time design patterns (if constexpr, template polymorphism) to eliminate runtime overhead.

Advanced Trace & Debugging (ISTO): Leverage ISTO standards (e.g., IEEE-ISTO Nexus 5001 Global Embedded Processor Debug Interface) for non-intrusive trace, performance analysis, and root-cause debugging of bare-metal applications without impacting timing behaviour.

Resource & Memory Management: Author deterministic, zero-heap applications using custom allocators, placement new, and RAII wrappers to guarantee zero memory leaks and block-free execution during time-critical payment processing.

Firmware Virtualization & Simulation: Build and manage cross-compilation toolchains targeting custom architectures. Set up and run automated test suites inside QEMU / Software-in-the-Loop (SIL) environments for EMV regression testing.

Sanitizer Instrumentation: Instrument code and debug complex runtime issues using memory, thread, and undefined behavior sanitizers (ASan, TSan, UBSan) integrated directly into CI/CD pipelines.

Demonstrated experience developing embedded software compliant with EMVCo specifications, ISO 7816, or ISO 14443 standards.

Understanding of secure elements, payment cryptography (RSA, DES/3DES, AES), and side-channel attack mitigation in a bare-metal environment.

Deep understanding of non-owning memory types (std::string_view) and explicit error-handling models without heap usage (std::optional, std::variant) to handle complex payment state machines safely.

Expert utilization of type-safe hardware mapping tools (std::byte) and strict safety enforcements ([[nodiscard]]).

Strong knowledge of disabling non-deterministic language features (e.g., building with -fno-exceptions and -fno-rtti) while preserving architectural safety.

Mastery of thread synchronization using lightweight, lock-free hardware atomics (std::atomic) over heavy mutexes to prevent priority inversions during synchronous I/O operations.

Technology stack

Tools & Technologies.

The platforms and technologies you'll use to build modern, enterprise-grade solutions.

C++17

Required

Embedded C++

Required

Bare-metal

Required

RTOS

Required

FreeRTOS

Required

Zephyr

Required

EMV

Required

EMVCo

Required

EMV L1

Required

EMV L2

Required

Contactless kernel

Required

Contact kernel

Required

ISO 7816

Required

ISO 14443

Required

APDU

Required

NFC

Required

RFID

Required

SPI

Required

I2C

Required

UART

Required

Requirements

Skills & Experience.

We value curiosity, collaboration and continuous learning. If you don't meet every requirement but believe you can make an impact, we'd still love to hear from you.

Essential

Required Qualifications

Embedded firmware development (bare-metal and/or RTOS such as FreeRTOS/Zephyr)

Modern C++ (C++17 or later) for embedded systems

EMVCo-compliant embedded development; EMV Contact and/or Contactless kernels (L1/L2)

ISO 7816 and/or ISO 14443 familiarity (smartcard/contactless)

APDU parsing and secure transaction workflow implementation

Payment/security cryptography basics: RSA, DES/3DES, AES

Secure elements and side-channel mitigation awareness in embedded context

Peripheral driver development: SPI, I2C, UART, CAN, DMA; NFC/RFID interfaces

Deterministic/zero-heap memory management (custom allocators, placement new, RAII)

Concurrency primitives for embedded: std::atomic / lock-free synchronization concepts

Ability to build with constrained runtime features (e.g., -fno-exceptions, -fno-rtti)

Advanced debugging/trace using IEEE-ISTO / Nexus 5001 (non-intrusive trace)

Cross-compilation toolchains and target-specific builds

QEMU / Software-in-the-Loop (SIL) testing for embedded binaries

CI/CD for embedded builds/tests (GitHub Actions, GitLab CI, or Jenkins)

Sanitizers: ASan, TSan, UBSan integration and interpretation

CMake build systems (modern CMake)

ARM Cortex-M and/or RISC-V familiarity; secure enclaves/TrustZone awareness

Preferred

Nice to Have

Template/compile-time design patterns (template polymorphism, if constexpr) to reduce runtime overhead

Use of std::string_view, std::optional, std::variant for safe non-allocating APIs

Use of std::byte and attributes like [[nodiscard]] for safety

Performance analysis and ultra-low latency optimization for transactional paths

Experience with VSCode and/or Kiro IDE

What you'll gain

More Than Just A Job.

We're committed to helping every team member grow professionally, personally and technically while working on meaningful projects.

Global Exposure

Collaborate with international clients and multicultural teams on enterprise programmes.

Continuous Learning

Expand your expertise through mentoring, certifications and hands-on project experience.

Career Growth

Take ownership, develop leadership skills and grow your consulting career over time.

Flexible Working

Hybrid and remote collaboration designed around trust and delivering exceptional outcomes.

People First

Join a supportive culture where collaboration, respect and long-term relationships come first.

Enterprise Projects

Work on meaningful technology initiatives for leading organisations across industries.

Apply

Apply for Senior Embedded Software Engineer (Payments/EMV, C++17)

One page, about two minutes. We only ask for what we actually need to have a first conversation.