AWS Cloud Architect with Nodejs/ Typescript

We need strong profiles on

• Node.js - sufficient depth to review Lambda design, conduct code reviews, and assess agent-generated implementation patterns.

Role :- Contract

Position Senior AWS Serverless Architect with NodeJs and AI/ML Experience (Dallas, TX - Hybrid - USA)

Experience: 10 years software engineering, 6 years focused on AWS serverless and distributed systems

# of positions: 2

Location: Dallas, Texas (Hybrid)

Job Description

AWS Serverless Architect

Role Summary

Own serverless and event-driven architecture across the full SDLC - design guidance, implementation reviews, and production governance. Define and enforce architectural standards for the existing polyglot codebase and all new feature development. Validate patterns extracted by the agentic code intelligence pipeline and provide feedback to improve extraction quality. These validated patterns are served to AI coding agents used by SDEs - making your architectural decisions the guardrails for AI-augmented development.

Team Context

• Solution Architect - owns end-to-end system architecture; you align AWS-specific patterns within that vision.
• AI Platform Engineer - builds the code intelligence pipeline; you validate extracted patterns and provide feedback.
• Software Development Engineers (SDEs) - Implement features and infrastructure across the full stack using AI coding agents guided by your validated patterns.

Responsibilities

• Define and maintain serverless reference architectures for Lambda, streaming workflows, data access patterns, and API design.
• Provide architectural guidance and reviews across all SDLC phases - design, implementation, code review, deployment, production.
• Own architectural oversight of the full polyglot stack - TypeScript Lambdas, PHP backend, Angular frontend, MongoDB, DynamoDB, OpenSearch.
• Define and govern IaC standards - module structure, naming, tagging, CDK/Terraform configuration review. SDEs author IaC with agent assistance; you review and enforce standards.
• Review and validate patterns extracted by the code intelligence pipeline. Classify as canonical, legacy, or requiring correction.
• Provide structured feedback to AI Platform Engineer to improve extraction accuracy and relevance.
• Validate Lambda design - concurrency, retries, idempotency, failure handling, cost efficiency.
• Own Kinesis-based and event-driven data flow guidance - data pipeline design, ordering guarantees, replay, dead-letter handling, integration points across Lambda, PHP, and Angular layers.
• Review agent-generated code from SDEs for architectural consistency - your reviews close the loop between patterns defined, patterns served to agents, and patterns actually implemented.
• Document architectural decisions, constraints, and trade-offs for team consumption and as input to the code intelligence platform.

Primary Skills

• 15 years software engineering, 6 years focused on AWS serverless and distributed systems.
• Deep expertise in Lambda-centric serverless architectures at scale.
• Event-driven, streaming, and data pipeline architecture - data flow design, ordering, replay, dead-letter handling, streaming-vs-batch trade-offs. Hands-on with Kinesis, SQS, EventBridge, or equivalent.
• TypeScript / Node.js - sufficient depth to review Lambda design, conduct code reviews, and assess agent-generated implementation patterns.
• DynamoDB - data modelling at scale, single-table design, GSI strategies, access pattern optimization. Non-negotiable.
• Document database experience - MongoDB, Couchbase, DocumentDB, or equivalent. Document modelling, query performance, aggregation patterns, polyglot persistence with DynamoDB. MongoDB preferred but not required.
• OpenSearch / Elasticsearch - index design, search patterns, analytics workloads, scaling.
• IaC (CDK / Terraform) - define standards, review configurations, enforce best practices. Heavy authoring done by SDEs with agent assistance.
• Architectural governance across the full SDLC - design reviews, code reviews, production readiness.
• Ability to reason about architecture from existing code, not just greenfield.