Our client is a leading technology company operating a large-scale digital ecosystem with a wide range of online services. The company develops and operates highly scalable technology platforms serving millions of users worldwide. With a strong focus on technology, innovation, and customer experience, the company continues to expand its digital services and invest in large-scale infrastructure and engineering capabilities.

About the Team
The Search Engineering team is responsible for developing and operating large-scale search, discovery, and navigation platforms.
The team builds highly scalable, reliable, and high-performance distributed systems that support multiple business domains and large volumes of traffic and data.
The Search Platform team is responsible for the reliability and operation of mission-critical search services. Engineers work closely with software developers, product managers, and QA engineers to continuously improve system performance, stability, and operational efficiency.

About the Position
We are looking for a highly motivated Senior Site Reliability Engineer to join the Search Engineering team.
In this role, you will be responsible for maintaining and improving the reliability of large-scale distributed systems. You will work across infrastructure, platform, and application layers, while contributing to automation, monitoring, performance optimization, and incident management.

This position is ideal for an experienced SRE or Infrastructure Engineer who enjoys solving complex technical problems and working with large-scale production environments.

Responsibilities

Your responsibilities will include, but are not limited to:

Participate in the design and deployment of production environments for new services, from infrastructure to service level

Monitor production systems and participate in on-call operations

Respond quickly to production incidents, including reporting, triage, troubleshooting, and resolution

Investigate system issues and identify root causes

Support and execute production releases, including occasional nighttime or out-of-hours operations

Improve system reliability, availability, scalability, and performance

Drive continuous improvement of operational tools and automation

Develop and maintain automation for repetitive operational tasks

Collaborate with software engineers, product managers, and QA engineers

Identify testing requirements and design appropriate testing strategies

Participate in performance testing and optimization

Support security testing and reliability exercises

Participate in disaster recovery and emergency response drills

Contribute to the improvement of engineering and operational processes

Mandatory Qualifications

- More than 8 years of work experience working in IT
- Excellent problem solving and troubleshooting skills
- Excellent teamwork and communication skills
- Strong Linux experience with understanding of system performance and reliability
- Experience analyzing and tuning performance of distributed systems
- Experience deploying and using configuration management tools (e.g., Chef, Ansible)
- Experience with observability tools (e.g., Prometheus, Grafana, Loki)
- Experience with container technologies and orchestration (Kubernetes)
- Experience automating tasks using shell scripts and/or Python
- Strong understanding of computer networking and common protocols
- Experience managing services built with Java

Desired Qualifications

- Experience automating processes for software testing and deployment (Jenkins)
- Experience working with Spark, Solr, Cassandra, or Kafka
- Experience with cloud storage solutions (Ceph, S3, MinIO)
- Experience working with a Git-based workflow
- Software development experience

Technical Environment

You may work with technologies including:

Operating Systems: Linux

Container / Orchestration: Docker, Kubernetes

Configuration Management: Chef, Ansible

Monitoring / Observability: Prometheus, Grafana, Loki

Programming / Scripting: Java, Python, Shell

CI/CD: Jenkins

Data / Distributed Systems: Spark, Solr, Cassandra, Kafka

Storage: Ceph, Amazon S3, MinIO

Version Control: Git

Infrastructure: Large-scale distributed and cloud-based environments

What We Are Looking For

We are looking for someone who:
Enjoys solving complex infrastructure and production issues
Has a strong sense of ownership for system reliability
Can investigate problems independently and identify root causes
Is comfortable working with large-scale distributed systems
Enjoys automation and continuous improvement
Can collaborate effectively with engineers and cross-functional teams
Is willing to participate in on-call and production support activities
Has a strong interest in improving system performance, stability, and scalability

Languages
English: Fluent
Japanese: Optional / a plus

Work Environment
Fast-paced, dynamic global environment with collaborative teams across multiple locations

Salary: ¥10M – ¥12M JPY per year (Senior level)
Location: Hybrid (4 days in the office, 1 day remote)
Office Location: Tokyo, Japan
Working Hours: Flexible schedule with core hours from 11:00 AM to 3:00 PM
Visa Sponsorship: Available
Language Requirement: English only

Apply now or contact us for further information:
[Aleksey.kim@tg-hr.com](mailto:Aleksey.kim@tg-hr.com)

Most of the biggest tech outages of the last thirty years started with something you could fit on a sticky note, a few characters or one setting or a command typed late at night. This page follows a few of them from the people they hit back to the change that started it.

After an STPA talk at SREcon I put the unsafe-control-action questions into the rules my AI coding agent reads (not provided, wrong context, too early or late or out of order, stopped too soon or applied too long). A first replay looked great, so I ran it properly.

Setup: three real past changes, replayed from the commit before each one. A controller taking over a value another controller wrote, automatic recovery for a worker that stops responding, and a dispatcher picking from a cache that can be stale. Three arms: no rule, a plain blast-radius checklist, the STPA rule. Two models, three runs each, 54 plans. Two blind judges graded each plan against the bugs the real review or production found, with method words stripped first. They agreed on about 90% of calls.

Results, real bugs found per plan out of 8: no rule 5.7, plain checklist 6.1, STPA 6.1.

STPA won clearly in one case, the stuck-worker recovery. For one model, only the STPA rule raised "is this timeout too long" and "stop waiting when it can't help". The checklist never did. In the stale-cache case STPA made the other model drop basics it found without any rule: visible check errors, a metric for the fix, a test that proves it.

And my first headline (one question going 1 of 6 to 5 of 6) didn't survive stricter blinding. The plain checklist reached the same score.

What I kept: the timing questions, next to a plain checklist. Three changes is not a study. Curious whether people who run STPA properly, with losses and hazards first, see the same thing.

Write-up with the charts and the exact rule: https://www.catchkill9.dev/posts/stpa-in-my-agent.html

When reviewing system design RFCs, static diagrams (draw.io, Excalidraw) treat a 1,200 RPS Redis cluster and a 200 RPS payment worker as identical boxes, hiding where fan-in queues actually saturate first.

Here is an open-source (MIT) browser-based queuing physics & chaos sandbox for testing these topologies interactively (no signup required):

Interactive Sandbox (Stripe Ledger Topology):

https://graph-flow-virid.vercel.app/?template=stripe-webhook-ledger

Live Netflix Chaos Edge Stream Topology:

https://graph-flow-virid.vercel.app/?template=netflix-chaos-streaming

GitHub Repository (MIT):

https://github.com/Hanubaki/GraphFlow

At 4.5x ingress load, queue utilization crosses 100% on the downstream synchronous database/worker hops first, causing p99 tail latency to spike non-linearly until upstream circuit breakers (OPEN -> HALF-OPEN -> CLOSED) isolate the fault. You can also paste your own docker-compose.yml, main.tf, or package.json to reverse-engineer your stack and export to Mermaid.js, Grafana k6 load scripts, Kubernetes HPA, or AWS Terraform.

Does this M/M/1 queuing degradation curve match how you model capacity planning in production, or do you rely purely on k6/Locust staging runs?