We're Hiring | Senior Developer / Architect (Telecom BSS/OSS)

Excelacom Technologies; Chennai District; On-site; INR 4,000,000 - 6,000,000; Full time

Job summary

Excelacom Technologies is seeking a hands-on Senior Developer / Architect with deep Telecom BSS/OSS domain expertise. You will own architecture end-to-end, drive design decisions, and write production code, shaping scalable solutions in a challenging product engineering environment.

You will work with Java 8/11+, Spring Boot, microservices, and modern data stores while proving architectural intent through implementation, refactoring, and collaboration with peers.

Qualifications

• Core tech stack and modern architecture choices (Java/Spring, microservices, REST).
• Messaging and data stores include Oracle, MongoDB, Redis with JPA/Hibernate.
• Security by design with OAuth2/JWT and cloud delivery patterns.

Responsibilities

• Own architecture end-to-end and drive design decisions to production.
• Stay hands-on in code; prototype, refactor, and ship alongside the team.
• Work confidently in existing codebases, identify limitations, and lead refactors.
• Formulate and evaluate solutions independently with clear reasoning.
• Defend and evolve technical decisions with measurable success.

Skills

Java (8/11/17+)

Spring Boot

Microservices

REST API design

Kafka

RabbitMQ

Oracle

Relational DB (JPA/Hibernate)

NoSQL (MongoDB/Redis)

Distributed systems

OAuth2/JWT

AWS

Container orchestration

Design patterns

Job description

Excelacom is looking for a hands-on Senior Developer / Architect with strong Telecom BSS/OSS domain expertise to drive architecture, build scalable solutions, and solve complex engineering challenges.

We are hiring a hands-on Senior Developer/Architect for our product engineering team. This is a deliberately senior, deeply technical role not a management or oversight position. You will own architecture and write code: making the hard design calls, then rolling up your sleeves to prototype, refactor, and ship them alongside the team.

The distinction that matters most to us: we are looking for an architect, not a task executor. You should be comfortable being handed an ambiguous problem and a real codebase, forming your own point of view, and defending it — rather than waiting for work to be broken down and assigned to you.

Technical skills

• Core: Java (8/11/17+), Spring Boot / Spring ecosystem, microservices architecture, REST API design.
• Messaging & streaming: Kafka/RabbitMQ
• Data: ORACLE, Relational databases (JPA/Hibernate) and NoSQL/in-memory stores (MongoDB, Redis) — including when to use which.
• Distributed systems: service boundaries, distributed transactions, resilience patterns (Circuit Breaker, Bulkhead, Rate Limiter, Time Limiter), caching strategies, handling large datasets, cross-boundary exception handling.
• Security: OAuth2 / JWT authentication and authorization flows.
• Cloud & delivery: container orchestration and AWS compute models (e.g. EKS vs. ECS vs. Fargate), CI/CD.
• Design: applied design patterns, system design, and the judgment to know when to split a component and what a good service boundary looks like.

What you'll do

• Own architecture end-to-end — drive design decisions and see them through implementation, taking responsibility from the whiteboard to production.
• Stay hands-on in the code — actively build, not just direct. You'll write production code, prototype approaches, and pair on the hard parts.
• Work confidently in existing codebases — navigate unfamiliar code, identify architectural and implementation limitations, and propose, prototype, and execute refactoring.
• Formulate and evaluate solutions independently — weigh trade-offs, choose a direction, and clearly articulate the reasoning behind it.
• Defend and evolve technical decisions — present your rationale with confidence, engage critique, and know how you'd measure whether a design succeeded.
• Set the technical bar for design patterns, service boundaries, resilience, and system quality across the product.

What we're looking for

• Domain knowledge – you must worked on Telecom domain and has good exposure in BSS/OSS components
• Hands-on seniority — you make both architectural and implementation decisions, and you still code.
• Codebase ownership — you can drop into existing code, spot what's structurally wrong, and lead the refactor to fix it.
• Independence — you formulate solutions, reason through trade-offs out loud, and confidently defend your decisions under scrutiny.
• Judgement & ownership — you take end-to-end responsibility, from design through implementation, and own the outcome.
• Confidence — for this role, seniority shows up as technical confidence and engineering judgment, not years or titles.