Software Engineering Manager

We operate data-intensive, two-sided marketplace products and quality systems where speed, integrity, and trust are non-negotiable. We're migrating key services from Go/Python to Java-using legacy displacement patterns-and need an Engineering Manager who blends people leadership with product and systems thinking. You'll turn ambiguity into outcomes, grow engineers and tech leads, and use AI tools responsibly to amplify throughput without compromising quality or safety.

What you'll do

Lead teams to outcomes

• Manage 6-10 engineers across one stream-aligned team
• Set measurable quarterly outcomes tied to product strategy
• Create focus and flow: limit work in progress, manage dependencies, and remove blockers quickly.

Coach and grow people

• Run high-quality 1:1s and career growth plans; give timely, actionable feedback.
• Level up first-time and developing managers or tech leads via shadowing, rehearsal, and explicit success criteria.
• Foster a psychologically safe, low-ego culture with high standards for design reviews, code reviews, and post-incident learning.

Own delivery and quality

• Drive predictable execution: roadmaps, sprint health, and on-time milestones.
• Uphold non-functional requirements: availability (e.g., 99.9% uptime), performance at scale (p95 target), secure-by-default.
• Ensure testing strategy is modern and layered-contract/consumer-driven tests, performance budgets, chaos/disaster-recovery exercises.

Partner on product discovery

• Work with Product and Design in continuous discovery: weekly user touchpoints, live metrics reviews, fast MVP slicing, and tight feedback cycles.
• Frame problems before jumping to solutions; choose impact over output and experiments over big bets.

Steer technical direction (with your leads)

• Co-author technical strategy and RFC/ADRs; pay down debt intentionally; keep architectures aligned with platform and infrastructure.
• Make pragmatic buy/build decisions; standardize interfaces and contracts across teams.
• Steer the Go/Python * Java migration

Raise the bar in the AI era

• Establish 'AI-auditor' practices: prompt discipline, code audit checklists, security reviews, and traceability of AI-generated artifacts.
• Use AI to accelerate-not replace-engineering judgment: scaffolding, tests, documentation, migration plans.

Hiring, performance, and compensation cycles

• Hire for product thinking, intrinsic motivation, architectural judgment, and healthy velocity.
• Run fair calibrations; contribute to merit, promotion, and leveling decisions with evidence and band awareness.

What good looks like

3 months:

• Established working relationships with Product, Design, Platform/Infra, and other development partners.
• Completed team operating model: defined boundaries, interaction modes (collaboration, X-as-a-Service, enabling), and first roadmap cycle.
• Identified top 2-3 technical risks or debt hotspots; created paydown plan with first slice in progress.
• Held first calibration conversations with direct reports; drafted initial growth plans.
• Completed team assessment: identified strengths, gaps, and hiring needs

6 months:

• Team hitting >80% of committed quarterly outcomes; shipping small, high-learning releases.
• Migration slice delivered: at least one service boundary migrated
• Engineering health trending up: fewer rollbacks, crisper incident write-ups, measurable reduction in key tech-debt hotspots.
• At least one engineer or lead demonstrably leveled up in scope, autonomy, or impact.
• Hired and onboarded at least 1-2 engineers; pipeline healthy for remaining gaps

12 months:

• Teams consistently hit outcome goals (e.g., p95 latency within SLO).
• Clear operating model with adjacent teams and fewer handoffs-more empowered, stream-aligned delivery.
• Testing strategy mature: contract tests, performance budgets, load tests, DR exercises routine.
• AI-auditor practices embedded; no AI-generated code shipped without review and provenance.
• Team fully staffed to target headcount; attrition within healthy range
• Succession planning in place: at least one team member ready for stretch or promotion, How we'll evaluate
• Leadership & coaching: Clear examples of growing others; how you handle difficult feedback and performance issues.
• Product & discovery: Ability to define outcomes, slice MVPs, and measure value; comfort killing ideas with evidence.
• Architecture & quality: System thinking, trade-offs at scale, testing strategy, and incident narratives.
• AI-enabled execution: Concrete stories where AI accelerated delivery and where you caught AI mistakes pre-production.
• Velocity with safety: How you ship fast without burning trust-compliance, privacy, customer impact.

Manager responsibilities (cadence & rituals)

• Weekly: 1:1s; metrics review (delivery, reliability, quality); unblock list; cross-team syncs.
• Bi-weekly: Roadmap/OKR check-in; risk register; debt intake and prioritization.
• Monthly: Talent calibration; hiring pipeline review; incident trends and corrective actions.
• Quarterly: Outcome planning with Product; performance conversations; compensation/merit inputs and leveling proposals.

• 2+ years managing software engineers (or tech leads) delivering production systems at meaningful scale.
• Prior senior/staff-level IC experience or equivalent architectural depth; comfortable with event-driven systems, data pipelines, and API contracts.
• Demonstrated product mindset: can translate business goals into measurable engineering outcomes and MVPs.
• Proven track record improving execution-planning, estimation, dependency management, risk mitigation.
• Fluency with modern testing approaches and production operations (on-call, incident response, blameless postmortems).
• Hands-on use of AI coding tools with an emphasis on auditing, security, and correctness.

Nice to have

• Experience in marketplaces, matching/allocation algorithms, identity/graph problems, or large-scale audience data.
• Led first-time managers or tech leads; coached through role transitions.
• Operating JVM services at scale.
• Building and evolving typed contracts with versioning and deprecation policy.