Technical Architect

Role Overview

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.

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 for safe reprocessing.
• Implement retry strategies, including exponential backoff and Dead Letter Queues (DLQs).
• Ensure failure isolation, recovery, and 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 interactions and events for asynchronous workflows and orchestration.
• Ensure high throughput, low latency, and secure service-to-service communication.
• Apply clean architecture principles, including layered or hexagonal architecture where applicable.
• Implement caching, connection pooling, and performance tuning.

3. Integrate AI Agents (Python Services)

• Treat AI as a decoupled, event-driven service layer.
• Design asynchronous execution through events.
• Implement timeouts, retries, and circuit breakers.
• Develop fallback strategies for degraded AI responses.
• Handle non-deterministic AI outputs safely.
• Work with OpenAI, Anthropic, and Amazon Bedrock.
• Implement prompt versioning, traceability, and response auditing.

4. Build Modern Frontend (Angular)

• Develop responsive Single Page Applications (SPAs) using Angular.
• Visualize real-time workflow execution and system state.
• Implement efficient state management and reactive programming using RxJS.
• Optimize performance through lazy loading and appropriate change detection strategies.
• Integrate event streams and WebSockets for live updates.

5. Identity & Security (SSO)

• Implement and integrate SAML, OAuth 2.0/OIDC, and CAS.
• Ensure secure token propagation across services.
• Implement role-based access control (RBAC) and attribute-based access control (ABAC).
• Ensure secure secrets management.
• Address zero-trust architecture and service authentication patterns.

6. Data & System Design

• Use PostgreSQL or similar RDBMS technologies with strong schema design discipline.
• Avoid tight coupling across services and shared database anti-patterns.
• Ensure data consistency, including eventual consistency where required.
• Maintain auditability and traceability.
• Design systems for multi-tenancy, high availability, data partitioning, and scalability.

7. Observability & Reliability

• Build first-class observability into every component.
• Implement structured logging with correlation IDs and trace IDs.
• Monitor metrics such as latency, throughput, error rates, and queue depth.
• Implement distributed tracing using OpenTelemetry or similar tools.
• Define and monitor SLIs, SLOs, and SLAs.
• Implement health checks and readiness probes.
• Configure alerting and dashboards using Prometheus, Grafana, or similar tools.
• Enable end-to-end traceability across event-driven workflows and AI calls.

8. DevOps & Platform Engineering

• Work in Linux environments with strong command-line proficiency.
• Use Git, Maven, and CI/CD pipelines.
• Build continuously deployable systems using Infrastructure as Code (IaC), including Terraform or CloudFormation.
• Ensure environment parity across development, staging, and production.
• Implement rollback strategies and safe deployment practices.

Non-Functional Requirements (Explicit Ownership)

The candidate will be responsible for designing systems that meet the following requirements:

• Scalability: Horizontal scaling and event throughput handling.
• Reliability: Fault tolerance and graceful degradation.
• Performance: Low-latency APIs and efficient asynchronous processing.
• Security: End-to-end secure architecture.
• Observability: Full system visibility and traceability.
• Maintainability: Clean code and modular design.
• Extensibility: Plug-and-play connectors and workflows.
• Cost Efficiency: Optimized infrastructure and compute usage.
• Compliance Readiness: Audit logs and access tracking.

Required Skills

Must-Have Skills

• 10+ years of experience in enterprise application development.
• Strong expertise in Java and Spring Boot.
• Strong experience with event-driven architecture using NATS, Kafka, or similar technologies.
• Strong Angular expertise, with at least 3+ years of SPA development experience.
• Experience with microservices architecture.
• Strong knowledge of SQL and Hibernate.
• Experience in distributed systems design.

Good-to-Have Skills

• AI/LLM integration experience.
• IAM and SSO systems, including SAML, OAuth 2.0, and CAS.
• Cloud platforms, preferably AWS.
• Workflow and orchestration systems.
• Experience with observability stacks such as OpenTelemetry, Prometheus, and Grafana.