Senior Systems Reliability Engineer

The Senior Systems Reliability Engineer applies software engineering discipline to reliability problems — designing, building, and operating the systems that make production software measurable, scalable, and self-healing. This role treats operational challenges as engineering problems: when a process is manual, it gets automated; when a failure mode is unknown, it gets instrumented; when a system degrades, the degradation is understood before it recurs.

At this level, the specialist owns SLO and error budget frameworks for assigned systems, architects the observability stack that the team relies on, leads engineering-driven incident response, and holds NERC/CIP compliance responsibility for assigned systems. This role partners directly with Software Engineers as a technical peer — participating in design reviews, influencing architecture decisions for reliability, and building the production readiness standards that govern how software ships. Advancement to Lead is based on demonstrated ability to define reliability engineering standards at the platform level, influencing practice across multiple teams and portfolios.

JOB DUTIES

• Performs complex reliability engineering work autonomously; recognized subject matter expert within the team and adjacent teams.
• Designs and builds production software systems, reliability tooling, and automation frameworks; treats operational problems as engineering problems to be solved through code.
• Owns SLO governance, error budget management, and observability architecture for assigned systems; leads engineering-driven incident response including failover scenarios.
• Holds NERC/CIP compliance responsibility for assigned systems; formally mentors less experienced specialists; may coordinate team delivery and on-call activities.

Core Expectations

The following expectations apply at all Systems Reliability Specialist levels. Scope and independence expand with each level.

• Engineer reliability solutions: when a process is manual and repeatable, automate it; when a failure mode is opaque, instrument it; when a system is fragile, redesign the failure boundary.
• Define and own SLIs and SLOs for assigned systems; treat error budgets as a shared engineering contract with development teams, not an operations metric.
• Respond to production incidents as an engineer: form a hypothesis, isolate the failure, resolve it, and close the loop with a post-mortem that addresses root cause.
• Instrument systems so that on-call responders have sufficient telemetry to diagnose and act without tribal knowledge.
• Participate in 24/7 on-call rotation; treat every alert as signal — either actionable or worth eliminating.
• Write production-quality code: reliability tooling, automation frameworks, and operational software are held to the same engineering standards as application code.
• Partner with development teams as a peer in design reviews; reliability is designed in, not bolted on after deployment.

Reliability Engineering

Senior specialists design and build the engineering systems that make production software reliable. This is software engineering applied to operational problems — the output is code, frameworks, and automated systems, not tickets and runbooks alone.

• Design, build, and maintain reliability tooling: automated remediation systems, self-healing infrastructure components, and operational software that reduces human intervention in production.
• Own SLO and error budget definitions for assigned systems; review error budget consumption with development teams and drive engineering decisions based on budget status.
• Architect and implement chaos engineering programs: define failure injection scenarios, automate resilience tests, and validate recovery behavior against defined SLOs.
• Build and maintain CI/CD reliability gates: automated canary analysis, progressive delivery validation, and rollback triggers based on SLI thresholds.
• Design capacity planning models for assigned systems; build tooling to project resource needs and surface capacity risks before they affect availability.
• Contribute to production readiness reviews: define and enforce the engineering criteria that a system must meet before it ships to production.
• Reduce operational toil through engineering: measure toil, track reduction targets, and build the automation that eliminates it.

Observability & Instrumentation

Observability is an engineering discipline. Senior specialists design and build the telemetry systems that make production behavior understandable — not just monitored.

• Architect MLTP (Metrics, Logs, Traces, Profiling) observability solutions using the Grafana LGTM stack (Loki, Grafana, Tempo, Mimir), Dynatrace APM, Splunk, and Datadog.
• Define and enforce instrumentation standards: structured logging schemas, metric naming conventions, trace context propagation, and continuous profiling configuration for assigned systems.
• Build distributed tracing coverage across service boundaries; identify and close observability gaps that produce blind spots during incidents.
• Design SLI instrumentation: translate user-facing reliability requirements into specific, measurable signals that accurately represent system health from the user's perspective.
• Build and maintain alerting frameworks: alerts must be actionable, calibrated to SLO burn rate, and free of noise; own alert quality as an engineering output.
• Correlate application performance data — JVM heap behavior, GC pressure, thread contention — with infrastructure events to enable root cause analysis across layers.

Incident Response & Problem Management

Incident response at this level is an engineering activity. Senior specialists lead the technical response to high-severity events, own the post-mortem process, and drive the engineering work that prevents recurrence.

• Lead high-severity incident response for assigned systems, including dual-datacenter failover execution; own the technical resolution from detection through remediation.
• Apply structured root cause analysis: distinguish symptoms from causes, identify contributing factors across system layers, and drive remediation that addresses root cause rather than surface behavior.
• Author post-mortems that produce actionable engineering work items — not process improvements alone; track remediation to completion and validate effectiveness.
• Diagnose complex cross-layer failures: Java/JVM application failures, distributed system race conditions, database connection pool exhaustion, messaging system backpressure, and cross-datacenter synchronization issues.
• Build and maintain incident response runbooks as engineering artifacts: automated where feasible, version-controlled, and validated during chaos engineering exercises.
• Participate in blameless post-mortem facilitation; model the engineering culture that treats incidents as system failures, not human failures.

Java Application Reliability

The primary application platform is Java/Spring Boot. Senior specialists are expected to operate at the intersection of application engineering and reliability — understanding the runtime deeply enough to diagnose, tune, and improve production behavior.

• Diagnose and resolve Java application performance problems in production: heap memory pressure, garbage collection tuning, thread pool exhaustion, connection leak detection, and class loading anomalies.
• Perform JVM performance analysis using heap dumps, thread dumps, and continuous profiling; translate findings into engineering recommendations for development teams.
• Instrument Spring Boot applications with production-grade observability: Micrometer metrics, structured logging with correlation IDs, and distributed trace integration.
• Diagnose failures across the Java application stack: Spring Boot service behavior, PostgreSQL and Oracle query performance, Kafka and ActiveMQ messaging reliability, and REST/SOAP API integration failures.
• Contribute to Java application design reviews with a reliability lens: identify failure modes, single points of failure, and observability gaps before code ships to production.

Platform & Infrastructure Engineering

Senior specialists build and maintain the platform engineering components that reliability depends on — container orchestration, infrastructure automation, deployment tooling, and environment governance.

• Design and operate Kubernetes and OpenShift workloads for reliability: resource quotas, pod disruption budgets, horizontal pod autoscaling, and liveness and readiness probe engineering.
• Build infrastructure-as-code for reliability infrastructure: Terraform modules, Ansible/AAP playbooks, and Azure Resource Manager templates that are tested, version-controlled, and peer-reviewed.
• Own dual-datacenter reliability architecture for assigned systems: synchronization validation, automated failover triggering, traffic management, and recovery time objective verification.
• Design and automate environment promotion pipelines: ensure that configuration, secrets, and infrastructure state are consistent and validated across development, test, staging, and production.
• Build and maintain automated patch compliance workflows; integrate CVE remediation into CI/CD pipelines rather than treating it as a manual operational process.

NERC/CIP Compliance

NERC/CIP compliance for assigned systems is an engineering responsibility at this level — not a documentation exercise. Senior specialists implement controls through code and automation wherever possible.

• Own NERC/CIP compliance for assigned systems: interpret applicable reliability standards, implement required controls, maintain evidence documentation, and prepare for regulatory audit.
• Engineer compliance controls into the platform where possible: automated hardening scripts, configuration drift detection, access control validation, and audit log integrity verification.
• Maintain currency on applicable NERC/CIP standards and ERCOT-specific regulatory requirements; escalate emerging compliance risks to the Lead or Manager.
• Participate in regulatory audit preparation: produce control evidence, respond to auditor inquiries, and coordinate with compliance stakeholders on findings remediation.

Technical Leadership & Mentoring

• Hold formal mentoring responsibility for Systems Reliability Specialist I and II team members: structured coaching on SRE practices, code review for reliability tooling, and career development conversations.
• Serve as the recognized technical authority on reliability engineering and Java application operations for the team; adjacent teams and development engineers seek out this specialist for guidance.
• Lead design reviews for systems within the team's scope; identify reliability risks and observability gaps before systems reach production.
• Set engineering standards for the team: post-mortem quality, observability instrumentation, chaos engineering practices, and on-call readiness.
• Contribute to the broader engineering organization: internal technical talks, SRE practice documentation, and shared tooling that other teams can adopt.

• Minimum 5 years of progressive experience in systems reliability, software with an SRE focus, or a closely related discipline.
• Demonstrated experience building and operating reliability engineering systems in production: SLO frameworks, observability platforms, chaos engineering programs, and automated remediation tooling.
• Strong software engineering fundamentals: proficiency in Python and Java with experience writing production-quality reliability tooling and automation.
• Deep Java/Spring Boot and JVM performance expertise: heap analysis, GC tuning, thread profiling, and application instrumentation.
• Expert knowledge of MLTP observability tooling: Grafana LGTM stack (Loki, Grafana, Tempo, Mimir), Dynatrace, and Splunk.
• Experience with Kubernetes and OpenShift: workload design, autoscaling, pod reliability, and container networking troubleshooting.
• Experience with infrastructure-as-code: Terraform, Ansible/AAP, or equivalent.
• Experience leading high-severity incident response and driving blameless post-mortem programs.
• Experience with dual-datacenter or hybrid cloud reliability architecture preferred.
• NERC/CIP compliance experience: control implementation, audit preparation, and regulatory engagement preferred.

• Bachelor's Degree: Computer Science, Software Engineering, MIS, or related field (Required)
• Master's Degree: Computer Science, Software Engineering, or related field (Preferred)
• A combination of education and experience that provides equivalent knowledge to a major in such fields is required.

• Azure — Preferred
• Certified Kubernetes Administrator (CKA) — Preferred
• ITIL Foundation or Managing Professional — Preferred

WORK LOCATION: Taylor, TX Hybrid 2 days per week.

The foregoing description reflects the minimum qualifications and the essential functions of the position that must be performed proficiently with or without reasonable accommodation for individuals with disabilities. It is not an exhaustive list of the duties expected to be performed, and management may, at its discretion, revise or require that other or different tasks be performed as assigned. This job description is not intended to create a contract of employment with ERCOT. Both ERCOT and the employee may exercise their employment-at-will rights at any time. #LI-DN

ERCOT is firmly committed to equal employment for all qualified persons without regard to race, sex, medical condition, religion, age, creed, national origin, citizenship status, marital status, sexual orientation, physical or mental disability, ancestry, veteran status, genetic information or any other protected category under federal, state or local law.

Expected Salary Range:

$109,000 - $150,000