Senior Manager, Software Engineering

Our Story:
Crisis Prevention Institute Inc. (CPI) is the worldwide leader in evidence-based de-escalation and crisis prevention training and dementia care services. Our programs teach professionals the skills to recognize, prevent, and respond to crises in the workplace. Since 1980, we’ve helped train more than 17 million people within service-oriented industries including education, health care, behavioral health, long-term care, human services, security, corporate, and retail.

At CPI, we are dedicated to changing behaviors and reducing conflict for the Care, Welfare, Safety, and Security of everyone. We believe the power of empathy, meaningful connections, personal safety, and security are the antidotes to fear and anxiety. It’s a philosophy that is central to everything we do, and traces back to our beginning.

As a member of the team, you can expect to:

• Make a difference through your work – You’ll be proud to tell your family and friends about what you do.
• Gain significant career experience only obtained within a fast-growing organization – Entry-level roles through executive leadership.
• Feel fulfilled and have fun – We work hard but make the time to build meaningful relationships and celebrate the wins.

The Role:
The Senior Manager, Software Engineering leads the product squads that build and operate CPI’s Integrated Training and Learning (ITL) platform: a cloud-native learning platform composed of 30+ C#/.NET microservices built on CQRS and event-driven patterns, communicating over Azure Service Bus, backed by Azure SQL, and delivered through a React single-page application to CPI’s learners, Certified Instructors, and customer administrators worldwide.
This is a hands-on leadership role, and the emphasis is on both words. The Senior Manager is accountable for the performance of the teams they lead — what those teams ship, how reliably it runs, how fast they move, and how much each engineer grows — and they earn that accountability by staying in the work: in design reviews, in incidents, and in the code. They set a high bar and hold the team to it, remove the obstacles the team cannot remove for itself, and build the relationships across Product, Design, Sales, Customer Success, and Enterprise Applications that let engineering move without friction. The role is measured by outcomes — delivery predictability, deployment frequency, reliability, cost efficiency, engineer retention and growth — not by activity or ceremony. The Senior Manager is a visible steward of the culture CPI is building in Product Engineering: curiosity, ownership, drive, experimentation, learning from failure, and continuous improvement.
CPI exists to prevent crises and make people safer. The Senior Manager is expected to keep that connection live for the team: every release is ultimately a practitioner who de-escalates a situation better than they could have before.

Team Leadership & Accountability:

• Lead two or more Product Engineering squads and the Lead Software Engineers who anchor them; own the performance, health, and output of those teams.
• Make expectations explicit and written: what “good” looks like at each level of the engineering ladder, what the squad has committed to, and how both will be measured.
• Own the team’s operating metrics and report them without being asked: deployment frequency, lead time for change, change failure rate, time to restore, SLO attainment, escaped defects, and on-call load. Use them to find problems, not to rank people.
• Make and meet commitments. Forecast realistically, surface risk to scope or date early, negotiate trade-offs with the product owner, and say no when no is the right answer.
• Give direct, timely, specific feedback in both directions; recognize strong work publicly and address sustained underperformance promptly, fairly, and decisively.
• Own the allocation decision with the VP of Engineering: how squad capacity is divided across new product work, platform investment, technical debt, and keep-the-lights-on — and defend that split with evidence.

Hands-On Technical Leadership:

• Stay in the code. Contribute production code regularly, pair with engineers on hard problems, and take on the unglamorous work when it is what the team needs — while never being on the critical path for a committed deliverable.
• Participate in technical design reviews as a credible technical voice; challenge complexity, ask for the simpler option, and require that designs account for failure, observability, and cost.
• Unblock the team actively: diagnose where work is stuck — a dependency, an unclear requirement, a flaky pipeline, a decision nobody will make — and clear it, personally if that is fastest.
• Partner with the Principal Software Engineer on the platform’s target architecture. The Principal sets technical direction; the Senior Manager ensures the squads can and do execute against it, and brings back the ground truth about where the architecture is failing real teams.
• Serve as an escalation point during significant production incidents: run incident command when needed, protect the responders, and communicate clearly to stakeholders while the team works.

Delivery, Quality & Operational Excellence:

• Drive the squads toward small batches and frequent, low-risk production deployments using trunk-based development, feature flags, and automated testing; treat a long-lived branch or a quarterly release as a defect in the system.
• Uphold and advance engineering standards across the squads — testing strategy, code review expectations, documentation, secure coding practices, and accessibility (WCAG 2.1 AA) — and make the standards easy to follow through tooling and templates rather than through reminders.
• Own the operational health of the squads’ services: SLOs defined, alerting meaningful, runbooks current, on-call rotation sustainable and fairly shared.
• Ensure blameless incident reviews happen and that their follow-up actions are prioritized and actually completed.
• Drive the incremental decoupling of ITL domain data from upstream enterprise systems so ITL owns its production data and can deploy independently; sequence this work so it lands alongside product delivery rather than competing with it.
• Own vulnerability remediation and compliance commitments for the squads’ services within agreed timelines.
• Own the team’s budget: headcount plan, tooling and vendor spend, and Azure cost for the squads’ services. Make technical and financial decisions that are responsible, accountable, justifiable, and defensible in accordance with organizational policies and procedures.

AI-First Engineering & Innovation:

• Lead adoption of AI-assisted development across the squads: set the norms for using these tools well, establish review and testing expectations for AI-generated code, and hold the line that the engineer owns the quality, security, and correctness of everything shipped.
• Measure adoption and impact honestly — baseline first, then track effect on delivery speed and quality — and act on what the evidence shows, including abandoning tools that do not earn their place.
• Remove the barriers to adoption that are actually stopping people: skill gaps, unclear policy, and the quiet fear of looking slow while learning. Model daily use in your own work.
• Create the conditions for innovation: protect time for time-boxed spikes and proofs of concept, insist on evidence in technical debates, and make it genuinely safe to try things that do not work.
• Partner with the Principal Software Engineer and product leadership to identify where AI capabilities can create measurable value inside the ITL product for learners, instructors, and customers, and bring those opportunities forward with a proposed proof of concept rather than a slide.

Cross-Functional Partnership:

• Build a genuine working partnership with Product Management and Design/UX: engage early in discovery, bring engineering constraints and possibilities to shaping rather than to handoff, and hold a shared definition of done.
• Partner with Sales and Customer Success: serve as a technical voice in significant customer conversations and RFPs when needed, establish a clear escalation path for customer-impacting issues, and close the loop so recurring support pain reaches the backlog.
• Partner with the Enterprise Applications and IT teams on integration and data ownership boundaries as ITL decouples from upstream systems of record.
• Demonstrate the squads’ work to business stakeholders and connect it to customer and business impact in their language, not in engineering’s.
• Communicate upward with candor: give the VP of Engineering and the executive team an accurate picture of progress, risk, and cost — especially when it is not the picture they were hoping for.
• Lead the team through change. CPI’s Product Engineering organization is actively transforming how it builds and ships; bring people with you, including the skeptics, and convert resistance into contribution.

Talent, Growth & Culture:

• Own hiring for the team: raise the bar, run a rigorous and humane interview loop, sell the mission credibly, and make the call.
• Develop engineers deliberately against the Senior, Lead, and Principal expectations: a current growth plan for every engineer, regular 1:1s that are theirs and not a status meeting, and real sponsorship for stretch work.
• Build the leadership bench: grow Lead Software Engineers into stronger technical leaders and identify future managers.
• Set the tone on retention: know who your flight risks are, know why, and act before the resignation rather than after it.
• Model learning from failure — own your own mistakes openly, in front of the team, and turn them into guardrails rather than blame.
• Perform other position-related duties as assigned.

You Need to Have:

• Bachelor’s degree in computer engineering, computer science, or a related field.
• Ten years or more of professional software engineering experience building and operating production web applications and distributed services
• Three years or more managing software engineers directly, including hiring, performance management, and career development
• Five years or more of hands-on experience with C# and .NET (ASP.NET Core, .NET 6+), with current enough skill to contribute production code and review designs credibly
• Experience leading teams building distributed, event-driven systems in production: message brokers (Azure Service Bus or equivalent), idempotency, retries, and eventual consistency
• Experience with CQRS, domain-driven design, or similar patterns, sufficient to hold teams to architectural consistency
• Working familiarity with React and modern TypeScript sufficient to lead full-stack squads
• Experience building and operating services in Azure (App Service, Functions, Service Bus, Azure SQL, Azure Monitor / Application Insights, Key Vault) or an equivalent cloud platform, including cost management
• Demonstrated track record of improving a team’s delivery performance against measurable outcomes (deployment frequency, lead time for change, change failure rate, time to restore)
• Experience establishing CI/CD, automated testing, and continuous delivery practices across more than one team
• Experience owning production reliability, on-call, and incident response for customer-facing systems
• Experience adopting AI-assisted development tooling on a team, including setting guardrails and measuring impact
• Experience partnering directly with product management, design, and go-to-market functions
• Experience leading a team through significant technical or organizational change
• Yearly personal development demonstrated by successfully completing an accredited software engineering course, acquiring a software engineering-related certification, or presenting a completed learning project to the team
• Curiosity: asks why before how, digs into unfamiliar code and systems, and seeks to understand the learner, instructor, and customer problem behind every request
• Ownership: treats the services and features they touch as theirs to keep healthy, from design through production support, and does not wait to be assigned a problem before solving it
• Drive: a bias toward shipping working software in small, frequent increments and following through until the outcome is achieved, not just the ticket closed
• Experimentation: comfortable proposing and running small, time-boxed experiments (spikes, proofs of concept, A/B tests) and letting evidence, not opinion, settle technical debates
• Learning from failure: participates openly in blameless retrospectives and incident reviews, shares mistakes as lessons, and turns them into guardrails, tests, or runbooks
• Continuous improvement: leaves every codebase, process, and document a little better than they found it
• Ability to hold people to a high standard while keeping their trust — direct about the gap, generous about the person
• Ability to make timely decisions with incomplete information, communicate the reasoning, and own the result
• Ability to stay technically hands-on without becoming the bottleneck, and to judge accurately which of the two a given week calls for
• Ability to translate engineering work into business terms (cost, risk, speed, reliability) for executives, and business priorities into concrete direction for engineers
• Ability to build durable working relationships across Product, Design, Sales, Customer Success, and IT without trading away engineering quality to do it
• Ability to manage multiple competing priorities and attain the best possible outcomes for the organization
• Ability to facilitate evaluation of technologies and achieve consensus on technical standards and solutions among a diverse group of engineers
• Demonstrated ability to attract, develop, and retain strong engineers
• Excellent verbal and written communication and effective listening skills; writes clearly and briefly
• Strong business acumen and strategic thinking ability
• Genuine connection to CPI’s mission, and the ability to keep the team connected to the practitioners and learners their work serves