Team Lead, Delivery Management

THE ROLE

The Team Lead owns what the Bolt delivery team ships across Element451’s AI-powered product experiences. This is a player-coach role: you lead and grow the team while staying close enough to the code and product to make real technical calls. You manage up to eight engineers and are accountable for the team’s delivery end to end — velocity, predictability, quality, and safe operation of customer-facing AI experiences, from planning until working software is live in production.

Bolt brings AI-powered and agentic experiences into the workflows colleges and universities use to recruit, enroll, and support students. Its product shape will continue to evolve as we learn from customers and the market. This role turns that direction into dependable product outcomes while helping the team navigate ambiguity, make sound technical trade-offs, and keep shipping predictably.

The role flexes with team size — genuinely hands-on while the team is small, and trending toward leadership as it grows. It reports into the Director, Engineering and owns a single team, not a department. Technical standards and architecture are owned by the Principal Engineers; the Team Lead reinforces them and escalates decisions beyond the team’s scope. See Appendix A for development lifecycle expectations.

Where the lines are: Product owns problem prioritization, product strategy, and desired outcomes. The Team Lead partners closely with Bolt Product leadership and owns team capacity, delivery commitments, execution, release readiness, and engineering quality for the Bolt team. Principal and Senior Engineers define and own technical standards and architecture within their domains. When work crosses product, platform, or team boundaries, the Team Lead coordinates with the relevant technical owners and makes dependencies and ownership explicit. The Director, Engineering oversees the team’s delivery, develops the Team Lead, and owns the system across teams.

EXPECTATIONS

Delivery & Execution

• Owns the Bolt team’s delivery end to end — velocity, predictability, quality, and production outcomes — from cycle planning until working software is in production, not merged or sitting in staging.
• Owns team-level cycle shaping and planning: sizes and scopes work to a deliverable cycle boundary, grounds commitments in honest engineering analysis, and represents the team’s capacity and constraints to Product before anything is agreed to.
• Maintains a clear, real-time understanding of the team’s capacity, workload, delivery risk, and operational health; surfaces concerns early — no surprises.
• Partners with Bolt Product leadership to turn product outcomes into coherent, deliverable engineering scope, while keeping cross-team ownership and dependencies explicit.

Quality, Standards & Release

• Owns the team’s engineering–QA contract — when QA engages in the cycle, what a ready handoff from engineering looks like, and what quality gates must clear before a release.
• Reinforces the technical standards and architecture owned by the team’s Senior and Principal Engineers — holds the team accountable to code quality, review thoroughness, testing, sound architecture, and responsible AI engineering, and creates the conditions for those standards to be applied consistently rather than only under pressure.
• Owns release health for the team — “done” means in production and operating as intended. Drives completed work to release and removes the organizational and process blockers that delay deployment.
• Treats AI quality as an engineering discipline. Ensures changes to agent behavior, prompts, models, knowledge retrieval, tools, and orchestration are evaluated proportionately to risk, with production-informed regression coverage, repeatable evaluations, explicit release gates, progressive rollout, monitoring, rollback, and feedback loops that turn failures into durable test coverage.
• Uses measured product and operational signals — including correctness, relevance, safety, latency, reliability, adoption, and cost where applicable — to understand release health, make trade-offs visible, and bring decisions to Product and Engineering leadership with evidence.

Hands-On Technical Engagement

• Stays hands-on where it counts, especially while the team is small — engages in technical challenges, reviews PRs on high-risk and high-signal work, and joins incident response. This is heaviest at small scale and trends toward leadership as the team reaches full size.
• Can engage substantively in the design and operation of production AI systems, including agent workflows, knowledge grounding and retrieval, tool use, human escalation, observability, evaluation, and safe rollout, without needing to be the organization’s machine-learning researcher.
• Escalates architectural and cross-domain technical decisions beyond the team’s scope to the Principal Engineers who own them, rather than making unilateral calls outside the team’s remit.
• Holds AI-assisted development work to the same bar as anything written by hand, and models disciplined, fully accountable use of AI tooling for the team.

People Leadership

• Leads, coaches, and grows a team of three to eight engineers — regular 1:1s, actionable feedback, and honest career development.
• Owns hiring for the team — sourcing, evaluation, and onboarding — and addresses underperformance early, directly, and constructively.
• Builds a team that can operate across product engineering and AI engineering concerns, and develops engineers’ ability to reason about both deterministic software behavior and probabilistic AI behavior.
• Builds a team culture of excellence, ownership, and psychological safety; celebrates collective wins and addresses friction before it compounds.

AI & Cross-Functional Leadership

• Builds customer-facing AI capabilities that are dependable enough to become part of institutions’ daily workflows, including agentic and knowledge-grounded experiences, intelligent automation, and AI-assisted workflows.
• Drives AI adoption as a delivery lever within the team — continuously finds where AI can remove constraints across the SDLC, pilots tooling, and measures impact against delivery outcomes.
• Partners across Product, Design, QA, and the rest of Engineering — surfaces delivery status, risk, ownership ambiguity, and resourcing needs early and credibly. No surprises.
• Represents the team’s constraints and capacity honestly in the Product–Engineering planning dialogue, and escalates cross-team blockers to the Director.

HOW YOU'LL SHOW UP

• Lives our values — builds team culture through behavior, not policy.
• Excellent by default — visibly unsatisfied with mediocre outcomes, without ruling through fear.
• Leads as a player-coach — willing to go hands-on when the team needs it, and to step back as it grows.
• Leads with service — removes obstacles for the team rather than managing around them.
• Puts the team first — builds cohesion, celebrates collective wins, and addresses friction before it compounds.
• Communicates with clarity and honesty — delivers hard feedback, escalates hard problems, and advocates for the team.
• Treats feedback as a gift — gives it to the team generously and well.

WHAT YOU BRING

• 6+ years of professional software engineering in a complex, multi-tenant SaaS product, including meaningful hands-on technical work.
• 1+ years leading engineers — as a manager, tech lead, or team lead. This can be your first formal management role, but you’ve owned outcomes through other people before.
• Enough technical depth in our stack — PHP/Laravel, TypeScript (NestJS/Angular), MongoDB, AWS — to engage substantively in architecture discussions, review PRs, and make sound trade-off calls.
• Hands-on experience delivering customer-facing AI or agentic capabilities in production, with working knowledge of knowledge grounding and retrieval, tool use, evaluation and regression testing, human-in-the-loop design, observability, latency, reliability, safety, and cost. You can speak concretely about how you evaluated behavior, managed failure modes, observed production performance, and released changes safely.
• A track record of delivering — owning velocity, predictability, and quality for a team or significant scope, all the way through to production.
• Comfort operating within a cycle-based product development methodology; familiarity with Shape Up or a comparable approach is a plus.
• A genuine commitment to building an AI-forward team. We’re a Cursor shop; Claude Code, Codex, or comparable tools are equally valued.
• Strong communication at both the engineering-detail and leadership-summary levels — effective in 1:1s, team retrospectives, product planning, incident reviews, and leadership reviews alike.

APPENDIX A

Development Lifecycle

This appendix defines phase-by-phase expectations for how a Team Lead operates across the development lifecycle for a single team. The Director owns the system that makes this work across teams; the Principal Engineers own technical standards and architecture.

Planning

• Owns cycle shaping for the team — works with Product, the team’s engineers, and Principals to size and scope work to a deliverable cycle boundary, grounded in honest analysis of capacity, complexity, risk, and cross-team dependencies. Ensures the team participates actively in refinement and represents the team’s capacity to Product before commitment.
• For AI work, ensures that intended behavior, success measures, known failure modes, data or evaluation needs, and rollout expectations are explicit enough to support an engineering commitment.

Design

• Ensures a design process is applied when a feature has broad implications, material AI behavior risk, or significant architectural risk, partnering with the Principal Engineers who own the design process. Makes sure design outcomes are documented and that raising the need for a design is treated as sound judgment, never a delay.
• Ensures design considers the full product path: knowledge and data dependencies, agent tools and permissions, human escalation, shared platform boundaries, observability, evaluation, latency and cost constraints, and failure behavior.

Develop

• Holds the team to consistent engineering standards — code quality, PR hygiene, review thoroughness, and unit testing — reinforcing the standards the Principals own.
• Monitors progress without micromanaging: aware of where each engineer is, surfaces blockers early, and removes obstacles.

Test

• Enforces the team’s testing obligations as part of done — unit tests ship with the code and integration tests cover paths that cross boundaries. Owns the team’s engineering–QA contract and resolves friction at the engineering–QA boundary before it becomes a delivery problem.
• Ensures AI behavior is tested with methods appropriate to the risk: deterministic checks where possible, representative regression datasets, calibrated evaluation where judgment is required, adversarial and failure-path coverage, and human review for sensitive workflows.

Release

• Owns release health for the team — “done” means in production and operating as intended. Drives completed work to release, follows the org-wide release standards the Director owns, and removes blockers that delay deployment.
• For material AI behavior changes, ensures rollout and rollback are deliberate, production signals are monitored, and regressions or unexpected cost, latency, safety, or quality changes have a clear response owner.