Senior Software Engineer - Platform

About CJ Engineering

Are we a good fit for you?

At CJ, we are passionate about software engineering. We build exciting software, with quality and maintainability in mind. We believe in common sense, simplicity, and efficiency. We practice critical thinking, challenge each other no matter the title, and believe in the wisdom of the team.

That makes us Engineers and not just developers. Here are some of the principles that set CJ engineers apart. 

• Engineering autonomy: Here, business decisions are made by business people, and technical decisions are made by technical people.

• Full stack: Expect to be involved and to gain competence in every aspect of software engineering, from frontend, to database, to requirements analysis, to testing, to helping choose technologies.

• Clean, Maintainable code: Code is read more often than it is written, so we put in the effort to write it well in the first place.

• Pairing: The highest quality code is produced by close collaboration, so we pair by default.

• TDD: Quality is baked into our process through Test Driven Development

• Ownership: Engineers own the full lifecycle of what they build—from design and implementation to deployment, monitoring, production support, and on-call rotations. If we build it, we support it.

• Operational Excellence: We embrace Infrastructure as Code, CI/CD, automation, and observability to build reliable systems and deliver software safely, efficiently, and at scale.

• We believe in Agile values, and incremental development. We constantly experiment, retrospect, and adjust.

• We are committed to finding out how AI can amplify our productivity. We view AI as a force multiplier, not a replacement for good engineering.

If this sounds exciting, we want to hear from you!

The Systems You Work On:

EngExp owns the systems below. You'll own their reliability, be the critical reviewer of changes to them, and raise the team's depth in them: 

• Observability & monitoring — Prometheus, Alertmanager, Grafana, and OpenTelemetry across every production region. This is not dashboard-building: you own cardinality budgets and recording-rule design, keep a production Prometheus healthy as it outgrows a single shard (federation / sharding / long-term store strategy), and own Alertmanager HA and the blast radius of alert-routing config. Deep Prometheus and Alertmanager expertise is a core requirement. 
• Kubernetes & cloud infrastructure — multi-region EKS clusters: upgrades, node group and Karpenter management, controller lifecycle, and add-on / configuration management. Identify failure modes before they happen (subnet IP exhaustion, API server latency, ArgoCD reconciliation lag, Prometheus cardinality, Karpenter consolidation disruption). 
• AWS networking — VPC design, subnet allocation and CIDR management, VPC peering, Transit Gateway, security groups, Route53, and NAT gateway topology across multiple accounts and regions, plus 24/7 networking alarms for all prod networking between clusters and squad resources. 
• CI/CD & artifact management — GitLab administration (runner fleet, AMI updates, cache, access - not just pipeline authoring), GitOps delivery through ArgoCD, and the Nexus artifact repository including its storage lifecycle as it grows. 
• Access & identity — Vault secrets management, IAM roles and service accounts for apps in clusters, cluster permission management for audit compliance, and AI model access management (including cost alerts and reporting). 
• Cost observability — OpenCost, EBS orphan cleanup, cost anomaly investigation, and rightsizing attribution across teams, so waste is attributable rather than shared overhead. 
• Internal tools & delivery — the container image build pipeline and base image standards, code audit tooling, HedgeDoc, and the UI CDN (S3 + CloudFront), plus adopted applications with no other owner. 

What You'll Do:

• Own the reliability and operability of the systems above - focused on what is happening and why 
• Establish and enforce platform standards: RBAC, admission webhooks, resource limits, LimitRanges, policy-as-code 
• Manage infrastructure-as-code with Terraform across AWS accounts 
• Act as a high-quality reviewer of infrastructure changes - Terraform, Kubernetes configs, CI/CD pipelines, observability config - catching subtle issues and long-term risks before they ship 
• Turn recurring requests (ingress, DNS, service accounts) into self-service workflows that are hard to misuse 
• Drive resolution of platform incidents with a focus on learning and lasting system improvement 
• Evaluate new patterns (Gateway API / Kgateway, claim-based self-service) on tradeoffs, not hype 
• Mentor less-senior engineers and raise the team's depth in the components we own 

Technologies We Use:

• Kubernetes / EKS (multi-cluster, multi-region), Karpenter, cert-manager, external-dns 
• Prometheus, Alertmanager, Grafana, OpenTelemetry (and long-term storage / sharding for Prometheus) 
• AWS networking (VPC, VPC peering, Transit Gateway, Route53, NAT Gateway, security groups, subnet/CIDR design across accounts and regions) 
• Terraform, AWS (IAM, EKS, S3, EBS) 
• ArgoCD, GitLab CI/CD, Nexus (artifact registry), Docker, container image build pipelines 
• Vault, OpenCost 
• Gateway API / Kgateway 
• Kubernetes controllers/operators (reconciliation patterns, restart safety) - Go experience is a plus, not required 

What We Look For:

• 6+ years of experience in software and/or infrastructure engineering 
• Bachelor's degree or equivalent experience 
• Deep, hands-on production experience operating Kubernetes and AWS at scale, across multiple accounts and regions 
• Real operational depth in at least one system we own beyond the cluster - most importantly the observability stack (Prometheus/Alertmanager at scale), but AWS networking, Vault, or artifact/CI infrastructure also count. We are filtering for people who have run these systems, not just used them. 
• Strong AWS networking judgment (VPC, peering, Transit Gateway, subnet/CIDR design) 
• A track record as a critical reviewer - spotting subtle infrastructure issues and long-term risks before they ship 
• Experience leading technical work and mentoring engineers; can manage, clarify, and plan around uncertainty 
• Effective communication and the ability to influence design in a product-focused way 

Nice to Have:

Prometheus long-term storage / sharding (Thanos, Cortex, Mimir, or equivalent) run in production 

• Experience owning a container image / base image pipeline 
• Policy-as-code (Kyverno / OPA) and admission webhook design 
• Building claim-based self-service platform capabilities 
•  

What Success Looks Like:

• Engineers can deploy and debug services without needing platform intervention 
• The systems we own are understood deeply enough that we stop making decisions we have to reverse 
• Production issues are understood quickly, not just reacted to 
• Platform changes are intentional and low-risk, and standards are clear and enforced