Associate Technical Architect

As an Associate Technical Architect at ZOOP, you will be responsible for designing, evolving, and improving the backend architecture of ZOOP's technology platforms. You will work closely with the engineering leaders, Tech Leads, and product teams to translate business and technical requirements into scalable, reliable, secure, and maintainable systems.

This is a hands-on architecture role. You are expected to have strong software engineering fundamentals, write and review production-quality code, understand distributed systems, participate in technical decision-making, and guide engineering teams in implementing architectural solutions. You will own architecture decisions for specific systems and services while contributing to the broader technical architecture of ZOOP.

The candidate will have responsibilities across the following functions:

Backend Architecture and System Design:

• Design scalable, highly available, and maintainable backend systems and services.
• Own the technical architecture of assigned products, platforms, and critical services.
• Translate product and business requirements into technical architecture and implementation strategies.
• Design APIs, microservices, data flows, integrations, and distributed systems.
• Evaluate system bottlenecks and design solutions for scalability, performance, availability, and reliability.
• Define appropriate patterns for service communication, data management, caching, asynchronous processing, and event-driven architectures.
• Participate in architecture reviews and challenge design decisions where required.
• Ensure architectural decisions are aligned with ZOOP's broader technology direction and standards.

Technical Leadership and Engineering Guidance:

• Work closely with Tech Leads and senior engineers to guide the implementation of architectural designs.
• Provide technical direction without directly managing the engineering team.
• Mentor engineers on system design, coding practices, scalability, reliability, and engineering best practices.
• Review major technical designs, RFCs, and implementation approaches.
• Help teams make pragmatic engineering decisions while balancing delivery timelines, technical quality, and long-term maintainability.
• Identify architectural risks early and drive their resolution.

Hands-on Engineering:

• Maintain a strong understanding of the codebase and remain hands-on with engineering where required.
• Write production-quality code and build POCs when evaluating architectural approaches or new technologies.
• Participate in code reviews for critical services and architectural components.
• Debug complex production and system-level issues when required.
• Work closely with engineers during implementation of complex architectural changes.
• Ensure architecture decisions are practical and can be implemented effectively by engineering teams.

Reliability, Scalability and Performance:

• Design systems with high availability, fault tolerance, resilience, and graceful degradation.
• Identify and eliminate single points of failure and architectural bottlenecks.
• Define appropriate approaches for retries, timeouts, circuit breakers, rate limiting, queues, caching, and failure handling.
• Review system capacity and scalability requirements as products and transaction volumes grow.
• Drive performance improvements across critical backend services.
• Participate in production incident analysis and identify long-term architectural fixes rather than only short-term mitigations.
• Ensure critical systems have appropriate observability, monitoring, alerting, and operational readiness.

Security and Engineering Standards:

• Ensure security is considered as part of system and API design.
• Identify architectural security risks and work with engineering teams to address them.
• Follow secure coding, authentication, authorisation, data protection, and secrets-management best practices.
• Contribute to defining and enforcing backend engineering standards across teams.
• Review critical architecture and design decisions from security and compliance perspectives.

Architecture Documentation:

• Create and maintain architecture documentation for critical systems and services.
• Write technical design documents, RFCs, architecture decision records (ADRs), and system design documents.
• Document system dependencies, data flows, integration patterns, failure scenarios, and operational considerations.
• Ensure architecture documentation remains current as systems evolve.
• Communicate complex technical concepts clearly to engineering and product stakeholders.

Technology Evaluation and Technical Strategy:

• Evaluate new technologies, frameworks, infrastructure components, and architectural patterns.
• Conduct technical POCs and benchmarks where required.
• Assess build-vs-buy decisions and recommend appropriate solutions.
• Evaluate technologies based on scalability, reliability, security, developer productivity, operational complexity, and cost.
• Help define technology standards and reference architectures for ZOOP.
• Stay current with developments in backend engineering, distributed systems, cloud infrastructure, and software architecture.

Technical Debt and Architecture Evolution:

• Identify significant technical debt and architectural weaknesses across systems.
• Prioritise technical debt based on business impact, engineering risk, scalability, reliability, and operational cost.
• Define and drive refactoring and modernisation strategies.
• Ensure short-term delivery decisions do not create significant long-term architectural problems.
• Help evolve legacy systems toward cleaner, scalable, and maintainable architectures.
• Establish migration strategies for major technology or architecture changes.

Collaboration:

• Work closely with the Engineering Leads on ZOOP's overall technical architecture and engineering direction.
• Collaborate with Engineering, Product, Platform, Security, Data, and other technical teams.
• Participate in architecture and design discussions for new products and major platform initiatives.
• Communicate trade-offs clearly to both technical and non-technical stakeholders.
• Act as a technical point of reference for complex backend architecture and system-design problems.

Who You Are:

The Associate Technical Architect is expected to operate close to architect level, while continuing to remain hands-on with technology.

The ideal candidate should be able to:

• Take an ambiguous technical problem and convert it into a clear system design.
• Understand the existing architecture and identify what needs to change and why.
• Design systems that are scalable, reliable, secure, and operationally sound.
• Make practical technology choices based on engineering and business trade-offs.
• Challenge existing technical decisions constructively.
• Guide Tech Leads and engineers through complex implementation problems.
• Write and review production-quality code when required.
• Identify architectural risks and technical debt before they become production problems.
• Clearly document and communicate architecture decisions.
• Own technical outcomes rather than simply producing architecture diagrams.

Requirements:

• 7-10 years of strong software engineering experience with significant exposure to backend systems and architecture.
• Strong understanding of software architecture, distributed systems, and backend engineering.
• Strong hands-on programming experience in Go and/or Node.js .
• Strong understanding of API design, microservices, asynchronous processing, and event-driven architectures.
• Strong experience with relational and NoSQL databases such as PostgreSQL, MongoDB, and ClickHouse.
• Good understanding of caching, messaging, queues, and distributed data processing.
• Experience working with technologies such as Redis and Kafka.
• Strong understanding of system scalability, performance, reliability, and fault tolerance.
• Experience designing systems that operate at meaningful production scale.
• Strong understanding of cloud-native application architecture and Kubernetes.
• Experience working with GCP or comparable cloud platforms.
• Strong coding and debugging skills.
• Experience reviewing production code and technical designs.
• Ability to understand and navigate large, complex codebases.
• Strong understanding of the software development lifecycle and engineering best practices.
• Excellent problem-solving and analytical skills.
• Strong written and verbal communication skills.

Nice to Have:

• Experience with Go-based backend systems and large-scale distributed architectures.
• Experience with GCP, Kubernetes, Istio, Kafka, Redis, PostgreSQL, MongoDB, BigQuery, ClickHouse, and Temporal.
• Experience designing high-throughput and highly available systems.
• Experience with event-driven and asynchronous architectures.
• Experience with observability platforms, monitoring, logging, tracing, and production debugging.
• Experience with CI/CD and engineering infrastructure such as Jenkins and GitHub Actions.
• Understanding of cloud cost optimisation and architecture-level FinOps considerations.
• Experience with security architecture, authentication, authorisation, secrets management, and secure API design.
• Experience leading large-scale refactoring, system migration, or modernisation initiatives.
• Experience working in a high-growth startup or fast-paced engineering environment.
• Experience creating architecture standards, RFCs, ADRs, and technical documentation.