Principal Engineer – Software Architecture and Modernization

Overview

Principal Engineer role focused on software architecture and modernization of legacy applications, with direct, hands-on contribution to implementation and production outcomes.

What you'll do

• Lead software architecture and modernization: shape the evolution of legacy applications into well-structured, domain-oriented software.
• Define target architecture, module and service boundaries, migration seams, compatibility strategies, and incremental paths that teams can implement safely.
• Stay deeply hands-on in code: contribute directly to critical implementations, prototypes, refactoring, code reviews, and production fixes.
• Work in backend code and frameworks such as Java/Springboot, Golang, Node/TypeScript, or similar backend ecosystems, and help teams improve application structure, runtime behavior, and maintainability.
• Design strong domain models and APIs: create clear domain abstractions, ownership boundaries, service contracts, and APIs.
• Improve how business rules are represented in code and keep consumers insulated from legacy storage and implementation details.
• Modernize application foundations: guide framework and runtime upgrades, dependency modernization, concurrency and lifecycle improvements, and decomposition of tightly coupled code.
• Use practical refactoring strategies that keep large systems releasable throughout the work.
• Engineer for correctness, performance, and reliability: diagnose difficult behavior through code, runtime evidence, database interactions, and dependency flows.
• Fix root causes in implementation and design, including concurrency defects, inefficient data access, resource contention, failure propagation, and recovery behavior.
• Improve data access and integration design: move business logic out of database-centric implementations and into testable application code.
• Design effective persistence, transaction, caching, messaging, and event-consumer patterns while preserving historical, reporting, and audit needs.
• Raise the bar for code quality and testing: establish strong practices for unit, integration, contract, and functional testing.
• Improve code review, static analysis, dependency management, feature controls, and validation so teams can change complex software with confidence.
• Create reusable engineering patterns: turn successful designs into clear patterns, reference implementations, libraries, and architecture decisions.
• Turn technical strategy into cross-team execution: translate architectural risk into code-level priorities, decisions, ownership, and sequenced implementation plans.
• Partner with engineering, product, security, and data teams to move complex software initiatives from design through working code.
• Look for ways AI can expand engineering leverage across code comprehension, design exploration, implementation, refactoring, test generation, debugging, documentation, and planning.

What you'll need

• Deep backend and distributed-systems engineering: substantial experience designing, building, operating, and evolving production backend systems, services, APIs, and distributed applications.
• Credible hands-on implementation depth: can move from architecture into code, configuration, instrumentation, and diagnosis.
• Exact experience with Java/Springboot or Golang or Node/Typescript is relevant, but the key is moving ideas into shippable software solutions rather than the technology itself.
• Service transformation and architecture judgment: can define service boundaries, domain ownership, migration strategies, integration patterns, and practical architecture decisions for complex existing environments.
• Production reliability and performance expertise: can trace difficult behavior through application code, runtime state, database interactions, and dependency flows, then implement fixes that improve correctness, concurrency, performance, and recovery behavior.
• Software design and refactoring depth: can improve large codebases through domain modeling, modular design, dependency management, incremental refactoring, and carefully chosen abstractions, without forcing risky rewrites.
• Data and integration depth: understands relational databases, SQL behavior, messaging, event consumers, data movement, caching, and the tradeoffs of separating applications from legacy data dependencies.
• Strong testing and code-quality discipline: treats automated testing, code review, static analysis, dependency health, secure coding, and production validation as essential parts of software design.
• Principal-level technical leadership: creates clarity across teams, challenges weak assumptions constructively, communicates risk in business terms, and helps groups converge on decisions they can execute.
• Opportunity-focused approach to AI-assisted engineering: actively looks for ways AI can expand engineering leverage and helps turn promising uses into repeatable practices.

Nice to have

• Experience modernizing large complex software systems, including runtime and framework upgrades.
• Experience decomposing monoliths, extracting services, or establishing modular boundaries within large existing applications.
• Experience with Oracle or other enterprise relational databases, Kafka or similar messaging systems, and complex data migration or reporting dependencies.
• Experience with profiling, runtime instrumentation, concurrency analysis, database-performance diagnosis, or tuning.
• Experience applying AI coding agents for codebase analysis, implementation, testing, and software modernization.

Details

• Location: Hyderabad Office, India.
• Work mode: Hybrid, with 2 to 3 days per week from the Hyderabad office.