Senior Software Engineer Team Lead

Team Lead / Senior Engineer Job Description 

Engineering Team Lead (Senior) — AI-First Product Development 

Location: Utah (wfh but in-office, expansion planned) Team: 8 engineers (VP Eng, Principal Architect, frontend/backend, data/product)  

Products: 

* Aria — AI workflow orchestration platform 

* Echo — Mobile analytics validation and QA automation platform 

About Enlighten AI Labs 

Enlighten AI Labs builds enterprise AI analytics products for Fortune 500 QSR and hospitality clients. Our flagship product, Aria, is an agentic AI insights engine built on a knowledge graph and ontology layer that delivers role-specific, automated analysis to field operations teams. Aria sits above existing BI and semantic layers, answering not just what the data shows but what it means and what should be done about it. McDonald’s and Wendy’s are launch clients, with active engagements across additional Fortune 500 brands. Our engineering model is AI-first and human-led: AI executes much of the implementation lifecycle, and engineers provide direction, technical judgment, verification, and accountability. 

Role Summary 

We’re hiring a hands-on Engineering Team Lead (Senior) to build the engineering foundation for a company replacing traditional enterprise business intelligence with agentic analytics workflow orchestration. Our product builders are vibe coders with decades of experience in customer analytics across multiple Fortune 500 brands. They use coding agents to turn deep domain expertise directly into production code, without the traditional handoffs between subject matter experts and engineers. Your job is to build the rails that let this team operate at full velocity.  

This is not a role for someone who wants to impose traditional process on a group that has already moved past it. It is a role for someone who recognizes that the bottleneck in modern product development is no longer team size or typing speed, it is the quality of the scaffolding underneath. You will design that scaffolding. You will write code daily, own backend and infrastructure foundations, and design the patterns and harnesses that let the team move from idea to production in days rather than weeks. You will replace the legacy sprint model with agentic iteration cycles where AI agents handle testing, project management, and code review as first-class contributors.  

Bottom line: you run ahead of the product team, laying the scaffolding before they need it, so velocity never breaks. 

Key Responsibilities 

* Lead day-to-day engineering execution for a small, cross-functional team while contributing code daily. 

* Stay ahead of product builders by establishing scaffolding, harnesses, and backend foundations before they are needed. 

* Own core backend architecture, agent orchestration, and cloud infrastructure across GCP and AWS. 

* Build reusable harnesses and patterns that enable rapid feature development by vibe coders and AI agents. 

* Use AI tools (Cursor/Claude Code workflows) to accelerate delivery while maintaining rigor. 

* Design and maintain API interfaces and database schemas that scale with the product across Fortune 500 deployments. 

* Integrate agentic testing, agentic project management, and agentic code review as core elements of the development workflow, not as assistants. 

* Establish production-ready cloud environments with appropriate security, isolation, and scalability, and enforce quality gates (type checks, linting, CI, DeepSource) before merging. 

* Replace the traditional two-week sprint model with faster, agentic iteration cycles, partnering with VP Eng and Product on sequencing, trade-offs, and technical risk. 

* Provide clear architectural guidance and documented patterns to keep developers unblocked 

* Convert recurring failure patterns into reusable guardrails and team standards. 

* Maintain production stability and client readiness even as the team ships at high velocity 

* Maintain clear documentation of architectural decisions and rationale. 

Leadership Expectations 

* Technical leadership: Set direction, make pragmatic architecture calls, lay scaffolding before the team needs it, and prevent over-engineering. 

* People leadership: Mentor engineers, elevate senior contributors, hire and shape the team going forward, and create absolute accountability for shipped outcomes. 

* Execution leadership: Reduce time from idea to production from weeks to days, keep work in tight agentic iteration loops, and protect quality under pressure. 

* Cultural leadership: Establish a development culture in which AI agents operate as first-class contributors rather than assistants, and model absolute ownership of shipped outcomes. 

Required Qualifications 

* 7+ years software engineering experience, including senior-level ownership of production systems at scale. 

* 2+ years leading engineers (formal lead or de facto technical lead), with demonstrated ability to build and shape a team. 

* Strong backend and infrastructure capability (Python/FastAPI service architecture, cloud infrastructure across GCP and/or AWS), with full-stack fluency to support frontend (React/TypeScript) when needed. 

* Proven ability to make architectural decisions that determine whether products scale gracefully under enterprise (Fortune 500) load. 

* Demonstrated success mentoring engineers and improving team delivery habits. 

* Strong communication: can align technical and non-technical stakeholders quickly and clearly, and make strategic decisions on tech stack and long-term system evolution. 

* High standards for security, testing, and operational quality. 

Preferred Qualifications 

* Experience in AI-assisted development workflows and model/tool selection. 

* Familiarity with workflow orchestration, agentic systems, or LLM-integrated products. 

* Experience with security/quality gates like DeepSource or equivalent SAST tooling. 

* Startup or small-team experience where breadth, ambiguity handling, and ownership are critical. 

How We Work (Non-Negotiables) 

* AI agents are first-class contributors; humans own outcomes. 

* Plan-first for non-trivial work (no jumping straight to coding). 

* Domain-expert review required before merge. 

* DeepSource is a hard CI gate for security/quality. 

* Simplicity bias: remove unnecessary complexity continuously. 

* Compounding engineering: review lessons become permanent guardrails. 

Tech Stack & Engineering Environment 

Our Team Lead is expected to be comfortable operating across a modern, AI-enabled product stack: 

* Frontend: React + TypeScript, Next.js (Echo), Vite-based React apps (Aria), CSS modules/design-system driven UI patterns. 

* Backend: Python services (FastAPI), Node/Electron services for desktop capabilities (ADB, MITMProxy, RTMP workflows in Echo). 

* AI/Workflow Layer: LangGraph/LangChain-style orchestration patterns, AI-assisted coding workflows in Cursor and Claude Code. 

* Data & Persistence: Supabase for auth/cloud data where applicable, local event storage patterns for desktop workflows, Convex for new data operations in Aria. 

* Quality & Security: Type checking, linting, CI pipelines, and DeepSource as required security/quality merge gate.  

* Developer Tooling: Cursor (plan + implementation workflows), structured command-based process (/preflight, /audit, /simplify), GitHub-based PR and review flow. 

* Deployment & Delivery: Automated CI/CD with gated promotion, preview environments for QA validation, and strong domain-expert review before production promotion. 

How we use this stack: We optimize for speed with control, AI accelerates implementation, while engineers lead architecture, verification, and production accountability. 

Success in First 6 Months 

* Time from idea to production for new features is reduced from weeks to days. 

* Agentic testing, agentic project management, and agentic code review are integrated as core elements of the development workflow. 

* PR quality and review efficiency measurably increase. 

* Fewer escaped defects through stronger planning and verification. 

* Engineers demonstrate stronger ownership and decision clarity. 

* Production stability and client readiness are maintained even as the team ships at high velocity. 

* Vibe coders ship features at maximum velocity without hitting infrastructure or backend bottlenecks. 

* Scaffolding, harnesses, and architectural patterns are in place ahead of where the product team needs them.