Senior Integration Engineer

How to Apply:

Please submit your application to careers.roa@pemnet.com

Job Title: Senior Integration Engineer

Location: Bangalore, India

Department: Corporate Global Information System

Position Summary:

As PennEngineering accelerates its Speed of Now transformation, we are seeking an effectively skilled Senior Integration Engineer who could build a governed, layered integration and API platform to optimize global information delivery across a dynamic business environment. The Senior Integration Engineer will own the architecture end to end foundation/service/orchestration tiers, a control plane for registry and policy, a runtime data plane for sync and async traffic and an emerging context plane exposing governed data to AI agents as permission-scoped tools. You'll partner with business stakeholders to connect stable systems of record with fast-moving digital products. This is a hands-on role on a small team where you'll define platform standards and implement them in code, often in the same week. Deep expertise in API governance, event-driven architectures and layered platform design is essential.

Key Responsibility:

• Define the standards for integration flows across sync, async/event-driven, orchestrated (Saga/compensating-transaction), and batch patterns, establishing when each applies rather than defaulting to one, and implement the reference patterns yourself.
• Set the resilience standard for every live call to a system of record (circuit breakers, timeouts, idempotency keys, and fail-fast behavior that protects both the source system and the front-end session) and build it into the shared components teams inherit.
• Establish the deployment standard for how integrations are packaged and run, whether as containers or AWS serverless, and make the call per workload rather than by default.
• Establish and enforce API documentation and contract standards (contract-first OpenAPI for sync, AsyncAPI for event-driven) that are mechanically checkable rather than policy-dependent.
• Architect the platform's agentic surface, exposing integrations as governed, semantically described tools that AI agents and operational harnesses can call safely, with guardrails around inputs, tokens and downstream system protection.
• Stand up observability as a platform standard across all tiers, including distributed tracing, metrics, structured logging, and SLOs, so failures are diagnosable across a distributed transaction and not just within one service.

Required Skills & Qualifications

• AWS- Production experience building on AWS, including serverless (Lambda, API Gateway, Step Functions, EventBridge or equivalent) and the networking/IAM boundaries that enforce governance.
• Integration patterns- Demonstrated depth across sync, async/event-driven, workflow orchestration, and batch, including when to use which and the failure modes of each.
• API documentation standards- Contract-first design with OpenAPI/AsyncAPI, where you've set the standard for a team rather than just consumed one.
• Architecting for agentic workflows- Experience designing LLM-facing tool/agent surfaces with guardrails around inputs, tokens, and downstream system protection.
• Observability- Hands-on with tracing/metrics/logging tooling and the standards behind them (OpenTelemetry or equivalent) across distributed systems.
• Containers- Docker and a container orchestration/runtime platform in production.

Preferred Qualifications:

• Amazon Redshift and/or SageMaker.
• Change data capture at scale, with an appreciation for why near-real-time capture off a transactional system of record is hard.
• Schema-registry-governed formats (Avro or similar) and enforceable data-contract governance.
• Enterprise ERP/CRM/PIM integration at scale.
• iPaaS familiarity, with a clear-eyed view of where it fits versus where it doesn't.

Key Competencies

• Integration & API Architecture – End-to-end design and ownership of layered platform tiers (foundation, service, orchestration), API governance, registry, and policy enforcement across sync and async patterns.
• Cloud-Native & Event-Driven Engineering – Hands-on implementation of API gateways,service meshes, message brokers, and streaming platforms, moving fluidly between architecture and code.
• Stakeholder Partnership & Platform Thinking – Collaborating with business leaders to translate needs into reusable, self-service integration capabilities serving both systems of record and digital products.
• AI Context Plane & Governance – Designing permission-scoped tool surfaces that expose governed data to AI agents while embedding security, compliance, and access controls by design.