About the Role Architect and build a scalable, event-driven, AI-enabled full-stack platform with strong ownership across backend, frontend, and system design. Drive systems that are observable, resilient, secure, and production-grade by design, not as afterthoughts.

Responsibilities

Core Responsibilities
1. Design Event-Driven Systems
Build systems using event-first architecture (NATS or similar), not REST-centric design
Define event contracts, schemas, naming conventions, and lifecycle flows
Ensure:
Idempotency (safe reprocessing)
Retry strategies (exponential backoff, DLQs)
Failure isolation and recovery
Loose coupling between services
Implement event versioning and backward compatibility strategies

2. Build Scalable Backend (Spring Boot)
~ Develop domain-driven microservices with clear bounded contexts

Use:
REST APIs (for synchronous UI interaction)
Events (for async workflows and orchestration)
Ensure:
High throughput and low latency
Secure service-to-service communication
Clean architecture (layered / hexagonal where applicable)
Apply caching, connection pooling, and performance tuning

3. Integrate AI Agents (Python Services)
Treat AI as a decoupled, event-driven service layer
Design for:
Async execution via events
Timeouts, retries, circuit breakers
Fallback strategies for degraded AI responses
Handling non-deterministic outputs safely

Work with:
OpenAI, Anthropic, Amazon Bedrock
Implement prompt versioning, traceability, and response auditing

4. Build Modern Frontend (Angular)
Develop responsive SPA using Angular
Visualize real-time workflow execution and system state
Focus on:
Efficient state management
Reactive programming (RxJS)
Performance optimization (lazy loading, change detection strategy)
Integrate with event streams / websockets for live updates

5. Identity & Security (SSO)
Implement and integrate:

SAML

OAuth2 / OIDC

CAS

Ensure:
Secure token propagation across services
Role-based and attribute-based access control (RBAC/ABAC)




Secure secrets management
Address zero-trust and service authentication patterns

6. Data & System Design
Use PostgreSQL (or similar RDBMS) with strong schema design discipline
Avoid tight coupling across services (no shared DB anti-pattern)
Ensure:
Data consistency (eventual where needed)
Auditability and traceability
Design for:
Multi-tenancy
High availability
Data partitioning and scaling

7. Observability & Reliability (Expanded)
Build first-class observability into every component:
Structured logging (correlation IDs, trace IDs)
Metrics (latency, throughput, error rates, queue depth)
Distributed tracing (OpenTelemetry or similar)
Define and monitor:
~ SLIs / SLOs / SLAs

Implement:
Health checks and readiness probes
Alerting and dashboards (Prometheus, Grafana, etc.)
Enable end-to-end traceability across event-driven workflows and AI calls

8. DevOps & Platform Engineering
Work in Linux environments with strong CLI proficiency
Use Git, Maven, CI/CD pipelines
Build systems that are:
Continuously deployable
Infrastructure-as-Code driven (Terraform, CloudFormation)
Ensure:
Environment parity (dev/stage/prod)
Rollback strategies and protected deployments

Non-Functional Requirements (Explicit Ownership) You will be responsible for designing systems that meet:
Scalability: horizontal scaling, event throughput handling
Reliability: fault tolerance, graceful degradation
Performance: low latency APIs, effective async processing
Security: end-to-end secure architecture
Observability: full system visibility and traceability
Extensibility: plug-and-play connectors and workflows
Cost efficiency: optimized infra and compute usage
Compliance readiness: audit logs, access tracking

Must-Have
• 10+ years in enterprise application development
• Strong expertise in:

- Java + Spring Boot
- Event-driven architecture (NATS/Kafka or similar)
- Angular (SPA development 3+ years)

• Experience with:

- Microservices architecture
- SQL / Hibernate
- Distributed systems design

📌 Technical Architect (Java Experience) (Gurugram)
🏢 QuickLaunch
📍 Gurugram