Gauge

• Create and maintain Agent Skills for domains such as software architecture, security, data, frontend, backend, and compliance • Define global Rules that control agent behavior across all projects • Create Workflows that standardize the most common development cycles • Review other Architects' Skills — ensuring instructions are clear, precise, and unambiguous for an AI agent • Monitor real-world usage of Skills and evolve the repository based on feedback from AI Engineers • Support onboarding of new AI Engineers — teaching how to operate the tools you created • Stay up to date with new agentic tools, models, and ecosystem patterns

• Translate business needs into structured specs — the starting point for any delivery • Select and trigger the correct Skills for each task from the repository maintained by Forge • Guide AI agents in Antigravity or similar tools to execute complex tasks • Validate outputs — functionality, adherence to standards, and expected business result • Report gaps and unexpected behaviors to the AI Architects team • Maintain delivery cadence — you are responsible for the product, not the code • Collaborate with business stakeholders to refine specs and ensure alignment before execution

• Atuar no desenvolvimento de aplicações Fullstack com forte foco em backend utilizando Node.js, TypeScript e NestJS. • Analisar problemas técnicos complexos de forma autônoma, propondo soluções escaláveis e sustentando tecnicamente as decisões tomadas. • Participar de discussões arquiteturais, avaliando alternativas, trade-offs e impactos técnicos. • Desenvolver e manter APIs, integrações entre sistemas e arquiteturas baseadas em microserviços. • Trabalhar com PostgreSQL, realizando otimização de queries, modelagem de dados, índices e melhorias de performance. • Implementar boas práticas de arquitetura e engenharia de software, garantindo qualidade, organização e escalabilidade do código. • Atuar com Clean Architecture, SOLID, Design Patterns e boas práticas de desenvolvimento. • Realizar code reviews técnicos, contribuindo para evolução da qualidade do time. • Apoiar tecnicamente outros desenvolvedores e participar de mentorias para profissionais júnior e pleno. • Trabalhar em conjunto com times de DevOps, produto e outras áreas técnicas para garantir estabilidade e eficiência das soluções. • Participar de processos de deploy, análise de pipelines, troubleshooting de ambientes e investigação de falhas. • Documentar fluxos, decisões técnicas e soluções implementadas. • Atuar em ambiente com múltiplos projetos e integrações simultâneas.

• Realizar manutenção evolutiva e corretiva em aplicação backend desenvolvida em Django e Django CMS • Implementar novas funcionalidades e melhorias solicitadas pelo negócio • Atuar em integrações com sistemas externos (APIs, serviços e plataformas parceiras) • Garantir qualidade do código aplicando boas práticas como SOLID, Clean Code e KISS • Criar e manter APIs e rotinas de integração • Realizar análise e correção de bugs em produção, garantindo estabilidade e performance • Trabalhar com versionamento e processos de deploy, em conjunto com o time técnico • Participar de revisões de código e contribuir para a evolução técnica do projeto

• Ensure the reliability, performance and availability of connectivity between systems by operating, diagnosing and evolving networks in distributed, hybrid and cloud environments, with a focus on traffic analysis, advanced troubleshooting and communication architecture between services. **Strategic AWS environment management:** • Operate and evolve complex, reproducible environments with high availability, performance and horizontal scalability, using services such as EC2, ECS, Lambda, RDS and S3. **Reliability and observability:** • Define, implement and evolve end-to-end observability practices (SLIs, SLOs, SLAs) with tools like New Relic, CloudWatch and custom dashboards; • Proactively identify bottlenecks and incidents. **Connectivity and network performance:** • Diagnose and resolve latency, packet loss and throughput issues in distributed environments; • Troubleshoot DNS, VPNs, firewalls and load balancers (L4/L7); • Analyze communication flows between services (cloud, on-premises and external integrations); • Support the definition and evolution of connectivity architecture between systems. **Automation and CI/CD:** • Design, maintain and optimize robust and secure pipelines (Jenkins, Bitbucket, GitOps) for continuous delivery of microservices and serverless workloads. **SRE culture and continuous improvement:** • Promote blameless post-mortems, chaos engineering and automation of operational tasks to reduce toil and increase team efficiency. **Security and governance (DevSecOps):** • Integrate best practices for IAM, secure networking, encryption, traffic control, vulnerability monitoring and compliance into the application lifecycle, including connectivity troubleshooting and communication analysis between services. **Documentation and knowledge sharing:** • Create and maintain clear documentation on architecture, automations, incidents and runbooks, driving autonomy and improving onboarding.

• Own solution and AI architecture: RAG, AI agents, and LLM-enhanced systems that are observable, testable, and governable — not demo-only. • Define model and data lifecycle from experiment through PoC, pilot, and production: evaluation, drift signals, retention, and classification aligned with security stakeholders. • Run hands-on feasibility work using agentic workflows: targeted PoCs (retrieval stacks, evaluation harnesses, integration spikes) driven through Cursor/Claude Code and AFA where applicable. • Define non-functional requirements and manage technical risk and debt: latency, scale, resilience, security, and cost — with mitigations and sequencing captured in ADRs and fitness assessments. • Create architecture artifacts in Git: C4 and data-flow views as diagram-as-code; infrastructure context with the Cloud Architect; UML or equivalent views where tooling generates them from models or code; threat models as structured, reviewable repository content — not unmanaged documents. • Harden and evolve AFA Cursor rules, agent skills (e.g., design-new-service, evaluate-design, review-pull-request patterns), and sub-agents so AI, API, security, and data standards match Pearson and ELL composable architecture expectations. • Define data architecture: logical and physical models as schemas, migrations, and manifests; SQL/NoSQL choices matched to access patterns and privacy constraints. • Shape DevSecOps and quality with the Cloud Architect, DevOps, and QA: CI/CD gates, contract and test expectations; architecture- and security-focused review using AFA pull-request verdict workflows alongside human reviewers. • Set performance budgets and evaluation criteria; support profiling, tracing, and tuning. • Work in Agile delivery: ADRs and Design Decision Records, spikes, and explicit trade-offs with product, security, infrastructure, and customer stakeholders. • Deliver early outcomes: current-state and target-state architecture for an active initiative, expressed as diagram-as-code and ADRs (trust boundaries, non-functional requirements); a prioritized roadmap; threat artifacts for sensitive paths; and clear handover criteria with the Cloud Architect, QA, and DevOps.

• Design and implement versioned HTTP APIs: OpenAPI/JSON Schema, authentication and authorization, validation, idempotency, and clear error models. • Build and run services on Azure: App Service or Functions, Storage, Service Bus or Event Grid, Key Vault, Managed Identity; apply VNet integration and private endpoints per architecture. • Deliver accessible front-end experiences; use a BFF or experience layer where it improves security and reduces inappropriate coupling between clients and domain services. • Integrate enterprise identity: OIDC/OAuth2, client credentials, token validation; follow zero-trust and least-privilege guidance from architects and security. • Consume Terraform or Bicep modules per Cloud Architect standards; avoid one-off infrastructure that drifts from platform norms. • Implement features on AWS when required (e.g. Lambda, API Gateway, S3, SQS, IAM) using prescribed patterns. • Instrument applications with structured logging, metrics, and tracing; meet testing and privacy expectations aligned with AFAs (for example observability, testing strategy, and zero-trust rules). • Contribute to hardening AFA Cursor rules, agent skills, and sub-agents for stack-specific patterns (e.g. API-first, Experience API, MCP) in collaboration with architects. • Produce handover inputs as versioned artifacts: ADRs, diagram-as-code, contract definitions in Git, and operational notes that receiving squads can adopt—not ad hoc documents outside version control. • Deliver early outcomes: at least one initiative increment shipped with contracts, automated tests, observability hooks, and reusable patterns in Git, plus AFA updates covering authentication, configuration, and environment promotion.

• Own test strategy per initiative: pyramid coverage, contract and schema tests, integration, E2E, and negative or security-relevant scenarios. • Build and maintain automation for APIs, UI, and messaging; integrate with CI using quality gates, reporting, and disciplined flake management. • Validate behavior on Azure: Functions or App Service, Storage, and Service Bus; provision identity and test harnesses in non-production environments. • Extend coverage to AWS when features require it, using Cloud Architect–approved environments. • Test identity flows deeply: OAuth2/OIDC, client credentials, scopes, and negative authentication cases. • Validate trust-boundary behavior: payload limits, tenant isolation, idempotency, and dead-letter handling per design. • Prepare handover as versioned artifacts: test packs in repo, CI definitions, contract test suites, and explicit ownership-transfer criteria for receiving squads. • Contribute to hardening AFA rules and skills for testing strategy, contract tests, and PR-time quality signals alongside architects. • Deliver early outcomes: baseline automated regression for an active initiative with CI gates; agreed test data and environment strategy with Cloud Architect and DevOps

• Design, implement, and maintain CI/CD pipelines: build, test, artifact promotion, environment promotion, and rollback—aligned with Cloud Architect patterns and enterprise change control. • Integrate Terraform plan/apply, security scanning, and policy checks into pipelines; support AFA-backed or architectural checks at pull-request merge. • Automate releases: versioning, artifacts, deployment strategies, and traceability from commit to production handover. • Author operational artifacts in Git: deploy and rollback paths, failure modes, and escalation context as diagram-as-code and structured runbook fragments; avoid wiki-only knowledge. • Wire observability into delivery: pipeline and application telemetry hooks (OpenTelemetry, logs, metrics, traces) so receiving squads inherit usable baselines. • Harden or extend AFA rules and skills for CI/CD, Internal Developer Platform, and delivery-time observability—with the Cloud Architect. • Clarify what receiving squads must own versus what AFAs and platform standards carry forward after handover. • Produce a handover bundle: pipeline definitions, environment and secrets-handling patterns (not secret values), dashboards-as-code or linked dashboard definitions, alert routing, ownership matrix, and promotion runbooks in the repository.

• Define, encode, and harden Pearson-aligned cloud and IaC standards as versioned Git artifacts: Cursor rules, agent skills, reference Terraform modules, and scaffolds delivered through AFAs (passive rules at edit time; on-demand skills for design, remediation, and architectural verdict), including Internal Developer Platform and CI/CD guardrails for agent-assisted changes. • Express platform and operations context as diagram-as-code (for example Mermaid or Structurizr) and ADRs in the repository—linked to AFA install and assessment—not unmanaged documents outside Git. • Own Terraform on Azure for AKS and adjacent services (networking, identity, secrets, storage, monitoring): module boundaries, state and pinning, drift control, tagging, environments, and cost attribution. • Align CI/CD with enterprise change control—pipelines, promotion, plan/apply, rollback—and wire in policy-as-code, drift detection, secret scanning, and compliance tags. • Implement least-privilege Azure RBAC, managed identities, Key Vault, and network controls; keep secrets out of source; support rotation and audit-ready evidence in Git. • Shape AKS patterns: node pools and upgrades (including GPU pools, device plugins, and time-slicing or equivalent where used), failure modes and capacity, observability hooks in modules and AFA patterns, and consistent Terraform/Helm touchpoints for SKUs, labels/taints, and add-ons. • Produce handover-ready repository bundles for receiving squads—deploy, upgrade, and rollback views, ownership matrix, operational artifacts—and define readiness criteria with DevOps.