Production Application Support Lead

You will own the stability, availability and performance of our production platforms. This is a hands-on lead/manager role that combines production support, DevOps and site reliability engineering (SRE). You will lead engineers, run major incidents, and read the code to find root causes. You will also use AI tools to cut toil and resolve incidents faster.

Accountable. You keep an eye on everything. Every production service, alert, incident and risk in your scope is yours to know about, and nothing should surprise you.

Responsible. The buck stops with you. When production is at risk, you know what to do, you decide, and you see it through to resolution.

Leadership. You own your team. You set the standard for on-call, coach engineers, back them during incidents, and answer for their results.

Technical. You know your stuff. You go deep on the platform, the data stores, the pipelines and the code, and your team trusts your judgment because you have done the work.

         Lead the production support function, including on-call rotations, escalation paths and 24x7 coverage.

         Command major incidents from detection through resolution, then run blameless post-incident reviews and drive the fixes to completion.

         Define and track service level indicators (SLIs), service level objectives (SLOs) and error budgets with engineering and product teams.

         Use Datadog to build monitoring, alerting and dashboards that catch problems before users do.

         Run and improve Kubernetes workloads in the cloud, including scaling, upgrades, capacity and cost.

         Support and tune PostgreSQL, MongoDB and Neo4j in production, including performance, backup, recovery and failover.

         Keep Confluent Kafka healthy: throughput, consumer lag, partitioning, retention and schema management.

         Strengthen CI/CD pipelines, release practices, rollback plans and infrastructure as code.

         Report on availability, incident trends, mean time to detect (MTTD) and mean time to resolve (MTTR) to senior leaders.

         Hire, coach and develop a high-performing team.

         Own the end-to-end incident management process: detection, triage, severity classification, escalation, communication, resolution and closure.

         Act as incident commander for Sev 1 and Sev 2 events, coordinating engineering, vendors and business stakeholders, and issuing clear status updates to leadership at set intervals.

         Own problem management: run root cause analysis (RCA), maintain the known error database, and track corrective and preventive actions to closure.

         Identify recurring incidents through trend analysis, and prioritize permanent fixes ahead of repeat firefighting.

         Set and enforce service level agreements (SLAs) for response and resolution, and report breaches with causes and remedies.

         Run change and release risk reviews with the change advisory board (CAB), and link incidents back to the changes that caused them.

         Maintain on-call runbooks, escalation matrices and major incident playbooks, and test them through regular incident drills.

         Run weekly and monthly incident, problem and service health reviews with engineering, product and business owners.

         Manage third-party and vendor escalations for cloud, platform and software issues, and hold vendors to their support commitments.

         Keep the incident and problem tooling (for example ServiceNow or Jira) accurate, and ensure tickets carry complete timelines, impact and root cause.

         Design and run a customer satisfaction (CSAT) process for all production support resources, with a survey after ticket closure, a defined target score and a review of every low score.

         Gather CSAT from business users, application owners and engineering partners, and turn the feedback into coaching and process fixes.

         Create quality gates for ticket handling: accurate categorization and priority, complete root cause and resolution notes, correct escalation, and knowledge article updates before closure.

         Audit a sample of closed tickets each month against the quality gates, score each engineer and team, and share results openly.

         Create release and handover gates, such as production readiness, runbook and monitoring sign-off, before a service moves to support.

         Measure quantitative performance for each support team and engineer: ticket volume, backlog and aging, first response time, time to resolve, SLA attainment, reopen rate, first-contact resolution and escalation rate.

         Build dashboards that combine quality and quantity metrics, so no one is rewarded for closing tickets fast at the cost of quality.

         Set targets and thresholds for each metric, run corrective plans where teams miss them, and recognize teams that exceed them.

         Use the data in performance reviews, capacity planning and staffing decisions, and report trends to senior leaders every month.

         Troubleshoot live production issues hands-on: pod crashes, node pressure, network policies, DNS, ingress, certificates and resource limits in Kubernetes.

         Analyze application logs, distributed traces, thread dumps, heap dumps and metrics to isolate root cause across microservices.

         Review code changes, configuration and release diffs to find the commit, dependency or setting behind a regression.

         Tune PostgreSQL queries, indexes, connection pools, vacuum and replication. Diagnose MongoDB slow operations, sharding and replica set issues, and Neo4j query plans and memory.

         Monitor and resolve Kafka issues: consumer lag, rebalancing, partition skew, broker health, connector failures and schema compatibility.

         Build and maintain infrastructure as code (Terraform) and Helm charts, and review changes made by the team.

         Write automation in Python, Bash or PowerShell for remediation, health checks and routine operations.

         Troubleshoot CI/CD pipeline failures, build and deployment issues, and container image and registry problems.

         Run load, failover and chaos tests to validate resilience, and fix the gaps they expose.

         Manage identity, secrets, certificates and network access in the cloud, working with security teams on vulnerabilities and patching.

         Tune cloud and cluster capacity, autoscaling and cost.

         Write and keep current runbooks, architecture diagrams and dependency maps for production services.

         Use Copilot and other AI tools to speed up log analysis, query tuning, script writing and incident summaries, and validate every output before it touches production.

         Review solution architecture and design documents for new and changing services, and flag reliability, scalability, security and operability risks before release.

         Map service dependencies, data flows and failure domains across the microservices estate. Use that view to set resilience patterns such as retries, circuit breakers, timeouts and graceful degradation.

         Partner with architects and engineering leads on platform design decisions, including multi-region and disaster recovery strategy, data store selection, and event-driven patterns on Kafka.

         Set production readiness standards, and gate releases on them: observability, SLOs, runbooks, rollback plans and capacity.

         Read and analyze application code to understand behavior in production, including concurrency, memory use, query patterns, error handling and retry logic.

         Review pull requests for operational risk, such as missing logging, unbounded queries, weak error handling and unsafe configuration.

         Trace recurring incidents back to design or code defects, and work with development teams to fix them permanently.

         Use static analysis, dependency scanning and code quality tools to find reliability and security risks early.

         Build and improve internal platform capabilities such as self-service environments, standard pipeline templates, golden paths and reusable Helm and infrastructure modules.

         Use AI tools, including GitHub Copilot, to generate and review automation scripts, pipeline code, infrastructure as code and runbooks, then test and validate before release.

         Apply AI to operational workflows: alert triage, log and trace summarization, incident timelines, post-incident report drafts and ticket classification.

         Automate remediation of known failure patterns through self-healing scripts, event-driven workflows and auto-scaling policies.

         Measure toil, set automation targets, and report time saved, incident reduction and MTTR improvement from AI and automation work.

         Define guardrails for AI use in production, including access controls, review requirements and audit trails.

         10+ years in production support, DevOps or SRE, including at least three years leading teams.

         Career progression from on-premises infrastructure or systems administration into cloud administration, DevOps and SRE, and then into technical leadership. You understand the full stack from hardware, networking and operating systems up to cloud-native services, and you use that depth to troubleshoot.

         Deep hands-on experience with a major cloud platform, Azure or AWS (compute, networking, identity, monitoring, resilience).

         Production-level Kubernetes expertise on a managed service such as Azure Kubernetes Service (AKS) or Amazon Elastic Kubernetes Service (EKS), including troubleshooting, Helm and deployment strategies.

         Working knowledge of PostgreSQL, MongoDB and Neo4j operations.

         Experience running Confluent Kafka in production.

         Strong grounding in microservices architecture, including service dependencies, API failures and distributed tracing.

         Proven use of Datadog or comparable observability platforms.

         CI/CD experience with tools such as Azure DevOps, GitHub Actions or Jenkins.

         Ability to read and debug code in at least one major language, for example Java, C# or Python.

         Track record managing high-severity incidents and communicating clearly with technical and business audiences.

         Practical experience applying AI tools, such as Copilot, in engineering or operations work.

         Terraform or Bicep experience.

         ITIL or similar service management practices.

         Azure, AWS, Kubernetes or SRE certifications.

         Experience in a regulated or large-scale enterprise environment.

Availability against SLOs, MTTD and MTTR, repeat-incident rate, CSAT scores, ticket quality gate results, SLA attainment, on-call health, automation gains, and the quality of post-incident follow - through.