Role &

- Responsibilities:

- Architectural Vision:

Define and champion the architectural vision and strategic roadmap for the full-stack application landscape.

- Frontend Architecture:

Lead the architectural design, governance, and evolution of highly scalable React.js/TypeScript UIs with advanced state management (Redux Toolkit).

- Backend Microservices Architecture:

Design, architect, and oversee robust, resilient, and scalable Java/Spring Boot microservices in containerized environments (e.g., Kubernetes).

- Serverless &
- Event-Driven Design:

Architect and optimize serverless workflows on AWS Lambda using Java/Quarkus, designing sophisticated event-driven systems.

- Cloud Deployment &

- Infrastructure:

Architect and govern end-to-end full-stack deployment on AWS (S3, CloudFront, etc.) for high availability, scalability, and security.

- Data Architecture:

Define and optimize data models and persistence strategies for various databases relevant to Java/Spring Boot applications.

- Distributed Systems &

- Resilience:

Architect resilient asynchronous data pipelines, event-driven systems, and advanced caching solutions within the Java ecosystem.

- UI/UX Architectural Guidance:

Provide architectural guidance for structuring and styling interfaces, ensuring consistency and modern web standards.

- AI/ML Integration Strategy:

Spearhead architectural integration of AI/ML capabilities into applications, defining patterns for leveraging relevant APIs and services.

- Advanced Data Processing:

Design and refine advanced data processing pipelines and database interactions, potentially including AI-specific pipelines.

- DevOps &

- CI/CD Governance:

Drive architectural design and governance of robust DevOps practices, including Git, Docker, and end-to-end CI/CD for both frontend and backend.

- Technical Leadership:

Provide technical leadership, mentorship, and guidance to engineering teams, fostering excellence and innovation.

- Cross-Functional Collaboration:

Strategically collaborate with product, ML, cloud, and design teams to translate requirements into scalable technical solutions.

- Technical Strategy &

- Innovation:

Contribute to overall technical strategy, evaluate emerging technologies, and drive innovation, including strategic application of AI-assisted development.

Skills Expectation:

Frontend Architecture:

- Core: React.js with TypeScript.

- Architectural Leadership:

Define and enforce best practices, design patterns,



and coding standards for large-scale React.js applications using TypeScript. Lead the selection and integration of core frontend libraries and frameworks.

- Scalability &
- Performance:

Architect highly performant, scalable, and maintainable user interfaces, ensuring optimal user experience across diverse devices and network conditions. Drive performance optimization strategies for complex React applications.

- Type System Design:

Design and implement robust, enterprise-grade type systems using TypeScript, ensuring solid type safety across the entire frontend codebase and API integrations.

- Component Strategy:

Develop and govern a reusable component library strategy, promoting consistency, reusability, and maintainability across multiple frontend projects.

- State Management: Redux Toolkit (and broader patterns).

- Strategic State Management:

Architect comprehensive state management solutions for complex, distributed applications, leveraging Redux Toolkit as a primary tool while evaluating and integrating other patterns (e.g., React Query, Context API) where appropriate.

- Data Flow Design:

Design efficient and predictable data flow architectures, ensuring data integrity, consistency, and optimal performance across the application.

- Performance &

- Debugging:

Lead initiatives for performance optimization and advanced debugging strategies for state management, including profiling and tooling selection.

- Cross-Application State:

Define strategies for managing shared state across multiple frontend applications or micro-frontends.

- Deployment &

- CDN Architecture:

- Cloud-Native Deployment Strategy:

Architect and oversee the deployment strategy for frontend applications on AWS, leveraging S3 for hosting and CloudFront for global content distribution.

- Edge Optimization:

Design and implement advanced CloudFront configurations for caching, WAF integration, origin shield, and edge functions (Lambda@Edge) to optimize performance, security, and cost.

- CI/CD Pipeline Ownership:

Design, implement, and govern robust, automated CI/CD pipelines for frontend applications, ensuring rapid, reliable,



and secure deployments.

- Observability &

- Monitoring:

Establish comprehensive monitoring, logging, and alerting strategies for frontend deployments and CDN performance.

Backend Architecture(Java):

- Microservices Architecture (Java with Spring Boot):

- Strategic Microservices Design:

Lead the architectural design and evolution of complex microservices ecosystems using Java and Spring Boot. Define service boundaries, communication protocols, and integration patterns.

- Resilience &
- Scalability:

Architect highly resilient, fault-tolerant, and scalable microservices, incorporating advanced patterns like circuit breakers, bulkheads, retry mechanisms, and distributed tracing.

- Containerization &

- Orchestration:

Drive the adoption and optimization of containerization (Docker) and orchestration (Kubernetes) strategies for Spring Boot microservices, including deployment, scaling, and management.

- Data Strategy:

Define and guide the data persistence strategy for microservices, including selection of relational and NoSQL databases, data modeling, and transaction management across distributed services.

- API Design &

- Governance:

Establish and enforce API design principles (RESTful, gRPC), versioning strategies, and API gateway integration for internal and external consumers.

- Security Architecture:

Design and implement robust security measures for microservices, including authentication, authorization, data encryption, and vulnerability management.

- Serverless Architecture (Java with Quarkus on AWS Lambda):

- Serverless Strategy &

- Optimization:

Architect and lead the adoption of serverless solutions using Java with Quarkus on AWS Lambda, identifying appropriate use cases and optimizing for cost, performance, and operational efficiency.

- Event-Driven Design:

Design and implement sophisticated event-driven architectures leveraging AWS Lambda, SQS, SNS, EventBridge, and other serverless components.

- Cold Start &

- Performance Tuning:

Develop and implement strategies to minimize cold start times and optimize the performance of Java-based serverless functions.

- Integration Patterns:

Architect seamless integrations between serverless functions and other AWS services, as well as traditional microservices.

- Observability &

- Management:

Define and implement comprehensive monitoring, logging, and tracing solutions for serverless applications, ensuring operational excellence.

📌 Technical Architect - Full Stack (Bengaluru)
🏢 Quantiphi
📍 Bengaluru