Engineering Manager, SDET

About the Role

As the first SDET leadership hire at Stord, you'll set the framework standards, AI-assisted test generation strategy, and CI-gated automation approach that every SDET you hire will build on, starting with a blank slate. Quality outcomes stay owned by engineering teams; you're building and leading the enablement function that lets them hit those outcomes at scale.

This role is for someone who has designed test architecture before and knows how to turn that judgment into a team, not just an individual practice. You can look at a fragmented testing landscape and see the two or three decisions that matter before the rest cascades, and you'd rather build the standard once and hire the team that scales it than keep executing inside someone else's framework.

Why This Role

• You're the first SDET leadership hire at Stord—the framework standards, tooling choices, and AI test infrastructure strategy are yours to set, not inherited
• You hire the team: every SDET you bring on builds on the standards, tooling, and technical direction you establish from day one
• AI-assisted test generation is a core part of the mandate from day one, for you and for every engineer you hire
• Your scope is cross-org by design—the framework and standards you set are what every embedded SDET, across every product group they land in, builds on
• You'll have direct visibility with R&D leadership on strategy and roadmap, not just execution
• You're building a high-bar, high-craft team on purpose—every hiring decision is yours, and the standard is not lowered to fill a seat faster

What You'll Do

• Team Building & Technical Standards: Hire the SDET team, defining and holding the technical bar rather than delegating it. Set framework standards, tooling decisions, and technical direction before the team's habits calcify. Establish what "tested" means at Stord before a feature reaches UAT.
• AI-First Test Automation Strategy: Own the AI-assisted test generation mandate—converting acceptance criteria and user stories directly into test scripts is the default way tests get built. Set the patterns and guardrails for where AI-generated tests are trustworthy versus where they need human review. Model and enforce AI-fluent ways of working across the team you build.
• E2E Framework Across Three Testing Surfaces: Build and own the automation strategy across interactive web application (UI), API, and Kafka eventing (event-driven/async) surfaces. Prioritize API-level integration testing first for speed to build and resilience, with UI and Kafka eventing coverage layered on as the framework matures. Set resilience as a non-negotiable design requirement: retry/backoff patterns, deterministic test data, and explicit handling of eventual consistency for async flows.
• Coverage & Regression Infrastructure: Build regression test registers and own contract/API test tooling across services. Wire coverage dashboards so coverage gaps are visible, not assumed. Define load and performance test frameworks that engineering teams can apply to their own stories.
• Test Environment Partnership: Partner with SRE on the dedicated Test environment—schema and config parity with production is an ongoing shared concern. Co-design the longer-term move to ephemeral per-PR environments for isolated load testing and PR-level E2E validation once the Test environment and framework are stable.

Required Qualifications

• E2E test framework design: Built and owned a Playwright (or equivalent) framework from scratch, not just written tests inside one someone else designed
• CI/CD test gating: Wired automated tests into CI (GitHub Actions or equivalent) so they actually block bad releases instead of running as an afterthought
• AI-assisted test generation: Built or led adoption of tooling that generates test coverage from specs, acceptance criteria, or user stories, and understand where that automation breaks down and needs human judgment
• Contract and API testing: Designed test tooling that validates service contracts, not just UI flows
• Event-driven/async testing: Understand the specific challenges of testing asynchronous, event-driven systems (Kafka or equivalent)—timing, eventual consistency, and how to build tests that don't flake because of them
• Coverage tooling and visibility: Integrated coverage tools (Coveralls or equivalent) into a team's workflow in a way that changed behavior, not just produced a dashboard
• CLI-native workflow: Comfortable driving your own day-to-day work and expecting the same from your team from the command line and agentic coding tools, not GUI-first
• Hiring and technical bar-setting: Hired for a technical function before and can hold a high, specific bar rather than relaxing it under time pressure

Required Soft Skills

• Ownership & Accountability: Own outcomes, not just activities. Take pride when your team ships; take responsibility and fix the system when something breaks
• Strong Communication: Communicate clearly with engineers, PMs, and executives. Translate technical complexity into business language and vice versa
• Delegation & Multiplication: Scale through people, not heroics. Develop team members and multiply impact through others
• Navigating Ambiguity: Set direction when requirements are evolving. Build alignment across teams and functions without formal authority
• Balanced Judgment: Balance innovation with pragmatic delivery constraints. Know when to push for quality and when to ship
• Directed AI-Assisted Development: Understand how AI coding tools work as a productivity multiplier and can guide your team's adoption while maintaining quality and independent technical judgment

Strongly Preferred

• Experience standing up a test engineering or QE function from zero, including the hiring, at a company past its early scaling stage
• Load and performance testing framework design (not just running someone else's load tests)
• Direct experience partnering with SRE/infra teams on environment strategy and parity concerns

Nice to Have

• Contributions to open-source testing frameworks or tooling
• A track record of growing SDETs or QE engineers into senior or technical leadership roles

What Success Looks Like

• 30 days: Audited current testing practices, proposed initial framework and tooling standards to R&D leadership, and have your hiring pipeline for the SDET team underway
• 90 days: Framework scaffolded and wired into CI (not yet mature). Critical order flow paths for your first embedded team covered by automation, starting with API-level integration coverage. First SDET hire(s) onboarded and ramping against the standards you set
• 6 months: Framework standards adopted across every SDET you've hired. UI and Kafka eventing coverage building on top of the API-first foundation. Resilience practices—retry/backoff, deterministic data, eventual-consistency handling—are the norm across the suite, not the exception