Platform Engineer · Chicago, IL

Sevgi Aslan-Baysal

I'm a platform engineer in Chicago. Over the past five years I've run infrastructure for two very different kinds of consumer traffic: a high-volume app with steady load around the clock, and a ticketing marketplace where an on-sale can multiply load in minutes. The goal was the same in both: make it uneventful. That means infrastructure declared in code, deployments where the merge is the only human step, capacity that follows load on its own, and observability that takes on-call from a spike on a graph to the exact request.

A growing part of that work is building AI agents for the teams around me. Platform and product engineers now use them every day to catch policy violations and debug incidents.

  • AWS SAA
  • CKAD

Featured work

9 clusters · 16 teams

Self-service delivery on EKS

A GitOps delivery path across multiple AWS accounts: teams ship by editing Helm values and merging — Argo CD does the rest.

  • Argo CD
  • Helm
  • EKS

How

Problem — deploys ran through tickets and hand-offs, and every team paid for the wait.

Built — desired state in git, Argo CD reconciling it continuously, and Helm values as the only interface a team has to touch.

Result — 16 teams deploy on their own across 9 clusters; the merge is the only human step.

Capacity in both directions

Autoscaling for on-sale demand

Dynamic node provisioning with Karpenter and queue-driven worker scaling with KEDA — capacity that follows load up and back down.

  • Karpenter
  • KEDA
  • EKS

How

Problem — on-sale traffic arrives in bursts far above baseline, and capacity has to be there before the queue backs up.

Built — KEDA scales workers on queue depth; Karpenter provisions nodes the moment those workers have nowhere to schedule, and consolidates them when the rush passes.

Result — spikes absorbed without a human in the loop, and spend that tracks real use.

Audit → enforce

Policy without the revolt

Kyverno guards the cluster; an AI agent does the work between audit mode and enforce mode — tracing violations to their source in git and building the case for each flip.

  • Kyverno
  • Agent skills
  • Claude Code

How

Problem — admission policies start in audit mode and tend to stay there: violations pile up unread, and the enforce flip is deferred because proving it safe costs an engineer-day nobody burns.

Built — an agent that traces each violation to the chart or values file that produces it, triages it into one of four buckets — fix the workload, exempt with a paper trail, fix the policy, or blocked upstream — ships the workload-fix PRs, and assembles the evidence case for each enforce flip.

Result — enforcement earned incrementally, with evidence. The agent never flips a policy itself; a human reviews the case and merges.

The platform I operate

Infrastructure as code

What
Infrastructure declared in files, not clicked together in a console.
How
A tool diffs the declared state against reality and applies the difference. The files live in git.
Why
Every change is reviewed and reversible; an environment can be rebuilt from nothing.

Containers and orchestration

What
An app packaged with everything it needs, run in fleets across many machines.
How
The orchestrator schedules containers onto nodes, restarts what dies, scales what's busy, wires the network.
Why
You declare what should run; it keeps that true.

Deployment automation (CI/CD)

What
The path from "someone changed something" to "it's running" — with no manual steps after approval.
How
CI checks every proposed change; CD builds, promotes, and releases every approved one.
Why
The human decision is the merge. Deploys become small, frequent, and easy to roll back.

GitOps

What
Git holds the desired state of the cluster.
How
An agent inside the cluster pulls git and reconciles continuously. Nothing pushes in — not people, not CI.
Why
Drift is reverted automatically, history is the audit log, rollback is git revert.

Observability

What
Explaining what a system is doing from the outside.
How
Metrics show that something changed; logs show what each part said; traces follow one request end to end.
Why
Correlation: from a spike on a graph to the exact pod's logs to the exact request.

Alerting

What
Detection plus delivery.
How
Rules evaluate metrics continuously; firing alerts are grouped, routed by severity, and paged to on-call.
Why
One failure is one page, not twenty — and only when a human is needed.

Identity and access

What
Zero long-lived credentials.
How
Every actor — CI job, workload — proves who it is and gets short-lived access scoped to its task.
Why
A leak expires in minutes and could only ever do one thing.

Secrets management

What
Credentials never live in git, images, or env files.
How
A secrets store holds them; workloads fetch at runtime by proving identity, not by presenting a password.
Why
Rotation propagates without a redeploy, so a leaked value dies fast.

Policy as code

What
Rules for what may run, enforced by machines instead of a wiki.
How
The cluster's admission layer rejects violations on submit; CI evaluates the same rules before merge.
Why
Nobody discovers a rule in production.

Autoscaling

What
Capacity that follows load, in two layers.
How
Pods scale by CPU or queue depth; nodes are added when pods can't schedule and removed when empty.
Why
Spikes are absorbed without a human, and spend tracks real use.

Environments and promotion

What
Separate copies of the platform with increasing protection.
How
The tested artifact is promoted by immutable digest — never rebuilt. Gates tighten as blast radius grows.
Why
What ran in staging is exactly what runs in production.

Queue-based decoupling

What
A queue between "work arrives" and "work is done".
How
Producers write and return; workers consume at their own pace and tolerate retries.
Why
A burst becomes a backlog that drains, not an outage — and workers can run on the cheapest capacity.

Skills

Infrastructure & delivery
  • Terraform
  • CloudFormation
  • GitHub Actions (OIDC)
  • Argo CD
  • Helm
Kubernetes platform
  • EKS
  • Karpenter
  • KEDA
  • Gateway API
  • ingress-nginx
  • external-dns
  • cert-manager
  • Docker
Observability
  • Prometheus
  • Grafana
  • EFK
  • Loki
  • Thanos
  • Jaeger
  • Alertmanager
  • OpenTelemetry
  • CloudWatch
Security & policy
  • IAM
  • Identity Center
  • IRSA & Pod Identity
  • Secrets Manager
  • Kyverno
Cloud & data
  • AWS Organizations
  • EC2
  • VPC
  • SQS
  • ECR
  • S3
  • Route 53
  • RDS (PostgreSQL, MySQL)
  • DynamoDB
  • Elasticsearch
  • Linux
AI & scripting
  • Claude Code
  • Custom agent skills
  • Context engineering
  • MCP
  • Bash
  • Python

Experience

  1. Sep 2023 — Present

    Platform Engineer · Vivid Seats · Chicago, IL

    • Built the self-service delivery path on EKS across multiple AWS accounts, with teams deploying their services through Argo CD by editing Helm values.
    • Rolled out Kyverno admission policy, with an AI agent doing the audit-to-enforce work of tracing violations to their source in git and shipping the fix PRs.
    • Owned the platform's autoscaling layer, with dynamic node provisioning through Karpenter and queue-driven worker scaling through KEDA, for capacity that followed load in both directions.
    • Consolidated workload identity onto EKS Pod Identity, removing the operational overhead of per-service policy reviews.
    • Wired the OpenTelemetry stack across the platform, collecting every container's logs and letting on-call jump from a stack trace to the exact request.
    • Remediated security audit findings by rotating exposed credentials and migrating all repository secrets to AWS Secrets Manager, enforcing a zero-hardcoded-secret policy.
  2. Aug 2021 — Sep 2023

    DevOps Engineer · Fetch Rewards · Chicago, IL

    • Cut infrastructure provisioning time from days to same day, migrating CloudFormation stacks to Terraform with zero downtime.
    • Reduced monthly AWS spend by right-sizing EKS node groups and moving old logs to cheaper storage.
    • Automated deployments with GitHub Actions and OIDC, revoking every long-lived AWS credential and proving with CloudTrail that none were still in use.
    • Enforced least-privilege security by scoping applications to dedicated IRSA roles, isolating each workload to read only its own secret.
    • Replaced Datadog with a self-hosted Prometheus stack and carried the CloudWatch cluster alarms over as alerting rules.

Education

  • Ph.D.School PsychologyUNC Chapel Hill · 2018
  • M.S.Ed.Counseling & Counselor EducationIndiana University · 2012
  • B.S.Elementary EducationMersin University · 2008

Beyond work

Nature

Plants at home, time outside whenever I can get it — ideally with a sunset.

Antique stores

I like wandering antique stores — someone's old is my new.

Playing instruments

Just for myself, not for an audience. At the moment it's a ukulele.

Contact

Open to platform, infrastructure, and DevOps work. If you'd like to talk, my inbox is open.