Technical Architect – Cloud, Distributed Systems & Microservices

Experience: 15+ Years

Role Overview

We are looking for an experienced Technical Architect with 15+ years of software engineering experience to design and drive highly scalable, secure, resilient, and cloud-agnostic enterprise platforms.

The architect will be responsible for translating business and product requirements into robust technical architectures and ensuring their successful implementation across engineering teams.

The ideal candidate must have strong hands-on experience with cloud-native technologies, distributed systems, microservices, Kubernetes, messaging, databases, security, observability, and large-scale production deployments.

This is a hands-on architecture role. The candidate is expected to participate in design discussions, review code and implementation approaches, troubleshoot complex production problems, and guide engineering teams—not limit the role to documentation and architecture diagrams.

Key Responsibilities

Architecture & System Design

- Own end-to-end architecture for complex enterprise applications and platforms.
- Design scalable, highly available, fault-tolerant and distributed systems.
- Define architecture for systems deployed across multiple nodes, clusters, regions and environments.
- Design platforms capable of supporting horizontal scaling and large concurrent workloads.
- Make appropriate architectural decisions around:
- synchronous vs asynchronous communication
- REST/gRPC/event-driven communication
- stateful vs stateless services
- consistency and availability
- caching
- distributed transactions
- data partitioning
- service discovery
- failure handling and recovery
- Identify architectural bottlenecks and proactively design for scale and failure scenarios.
- Define architecture standards, patterns, reference architectures and engineering guidelines.

Microservices & Distributed Architecture Strong expertise in designing and implementing microservices-based architectures, including:

- Service decomposition and bounded contexts
- API design and versioning
- REST and gRPC
- Event-driven architecture
- Asynchronous processing
- Distributed messaging
- Service discovery
- Distributed caching
- Idempotency
- Retry and backoff strategies
- Circuit breakers
- Distributed locking
- Eventual consistency
- Saga and distributed transaction patterns
- Rate limiting and throttling
- API gateways
- Configuration and secrets management

The candidate should understand failure scenarios inherent in distributed systems, including network partitions, partial failures, duplicate messages, out-of-order processing, race conditions and consistency challenges. Cloud & Cloud-Agnostic Architecture

Strong experience with at least one major cloud platform such as Azure, AWS or GCP, along with the ability to design applications without unnecessary dependency on proprietary cloud services.

The candidate should understand how to build platforms that can operate across:

- Public cloud
- Private cloud
- On-premises environments
- Hybrid environments
- Multi-cloud environments

Strong understanding of:

- Containers
- Kubernetes
- Docker
- Kubernetes networking
- Ingress and load balancing




- Persistent storage
- Auto-scaling
- High availability
- Multi-zone deployments
- Disaster recovery
- Infrastructure as Code
- Secrets and certificate management

The architect should be able to evaluate the trade-offs between using cloud-native managed services and cloud-agnostic technologies. Kubernetes & Distributed Deployments

Strong practical understanding of production Kubernetes environments, including:

- Deployments
- StatefulSets
- DaemonSets
- Services
- Ingress
- ConfigMaps and Secrets
- Persistent Volumes
- Horizontal/Vertical Pod Autoscaling
- Pod disruption and availability
- Resource requests and limits
- Health/readiness/liveness probes
- Kubernetes networking
- Rolling deployments
- Zero/minimal-downtime upgrades
- Cluster and workload troubleshooting

Experience designing applications deployed across multiple Kubernetes nodes/clusters/sites is highly desirable. Messaging & Event-Driven Systems

Strong experience with technologies such as:

- Apache Kafka
- RabbitMQ or equivalent messaging systems

Must understand:
- Topics and partitions
- Consumer groups
- Ordering guarantees
- Delivery semantics
- Offset management
- Message retries
- Dead-letter handling
- Backpressure
- Idempotent consumers
- Schema evolution
- Message duplication
- Large-scale event processing

Data Architecture Strong understanding of both relational and NoSQL databases.

Experience with technologies such as:

- MySQL / SQL Server
- MongoDB
- Redis
- OpenSearch / Elasticsearch
- Analytical databases such as ClickHouse

Expected knowledge includes:
- Data modelling
- Indexing
- Query optimisation
- Replication
- Sharding/partitioning
- Transactions
- Consistency models
- Distributed caching
- Database scalability
- High availability and disaster recovery

The candidate should be capable of selecting the appropriate data technology based on the workload rather than applying a single database technology to every problem.

Security Architecture

Strong understanding of enterprise application security, including:

- OAuth 2.0
- OpenID Connect
- SAML
- JWT
- RBAC
- Authentication and authorization
- API security
- mTLS
- Certificate management
- Secrets management
- Encryption in transit and at rest
- Zero Trust principles
- Secure service-to-service communication
- OWASP security principles

Security must be considered as part of architecture and design rather than as a post-development activity. Observability & Production Engineering

Experience designing production-grade observability covering:

- Structured logging
- Metrics
- Distributed tracing
- Application performance monitoring
- Health monitoring
- Alerting

Experience with technologies such as:
- OpenTelemetry
- Prometheus
- Grafana
- OpenSearch / Elasticsearch
- Jaeger or equivalent platforms





The architect should be capable of diagnosing complex issues spanning multiple services and infrastructure components. Performance, Scalability & Reliability

Responsible for defining and reviewing:

- Performance requirements
- Scalability targets
- Availability targets
- Capacity planning
- Load and stress testing approaches
- Failure and recovery scenarios
- Disaster recovery strategy
- RPO/RTO requirements

Should understand architectural techniques for supporting high-throughput and high-concurrency systems.

Engineering Leadership

- Provide technical leadership to engineering teams.
- Mentor senior developers, technical leads and architects.
- Conduct architecture and design reviews.
- Review critical implementation and code where necessary.
- Establish coding and engineering standards.
- Challenge designs that introduce unnecessary complexity or technical debt.
- Conduct technical root-cause analysis for major production incidents.
- Drive architectural improvements based on production learnings.
- Work closely with Product, Engineering, DevOps, Security and QA teams.

The architect remains technically accountable for whether the architecture actually works in production. DevOps & Delivery

Robust understanding of

- CI/CD pipelines
- Git-based development workflows
- Infrastructure as Code
- Automated deployments
- Rolling deployments
- Blue/Green deployments
- Canary deployments
- Automated testing
- Release management
- Environment management

Experience with tools such as GitHub Actions, GitLab CI, Jenkins, Azure DevOps, Terraform, Helm or equivalent technologies is desirable. Programming & Hands-on Technical Capability The candidate should have strong software engineering fundamentals and significant development experience in one or more modern languages such as:

- Go
- Node.js / TypeScript
- Python

Although this is an architect position, the candidate must be capable of reading, reviewing, debugging and, when necessary, writing production-quality code or proof-of-concept implementations.

Architecture Documentation

Expected to create and maintain:

- High-Level Designs (HLD)
- Low-Level Designs (LLD)
- Architecture Decision Records (ADR)
- Sequence diagrams
- Component diagrams
- Deployment architecture
- Data-flow diagrams
- API contracts
- Failure-flow documentation
- Security architecture
- Capacity and scalability models

Architecture documents must clearly communicate decisions, alternatives considered, trade-offs and rationale, rather than merely describing components.

Required Experience

- 15+ years of overall software engineering experience.
- Significant experience architecting enterprise-grade applications.
- Strong experience with distributed systems and microservices.
- Strong experience with cloud and Kubernetes-based deployments.
- Experience building highly available and scalable production systems.
- Strong understanding of databases, caching and messaging.
- Strong understanding of application and distributed-system security.
- Experience designing APIs and integration architectures.
- Experience troubleshooting complex production systems.
- Demonstrated ability to make architecture decisions based on measurable trade-offs.

📌 Engineering Manager (Pune)
🏢 Accops
📍 Pune