// AI ENGINEER & TECH LEAD

Kevin
Bayter

I build AI systems that survive production.

AI Engineer and tech lead. I modernize critical payments and high-traffic platforms at Mercado Libre and WOM Colombia, and design agents with deterministic guardrails where failure is not an option.

View projects → ./contact
open to new challenges | Bogotá, Colombia | GMT-5
kevin@bayterx: ~/init
5+
years building production systems
2
teams led as tech lead
100%
of the team ships with my platform
24/7
payments & high traffic in production
kevin@bayterx: ~/stack
❯ ls ./tools --icons
Kafka Spring Kubernetes AWS Redis Playwright Terraform Go TypeScript Java Kotlin Node.js React Next.js GraphQL PostgreSQL Docker Grafana Datadog GitLab
# 20 tools · what I build and run production systems with
~/skills $ ls --group

Skills

From agent design with deterministic guardrails to resilient payment platforms: depth across the whole stack.

[1] ai_agents

Production agentic systems with deterministic guardrails.

Agents in production LLMs (OpenAI-compatible) Tool orchestration Structured extraction Deterministic guardrails Golden tests
[2] backend_payments

High-traffic reactive and transactional flows.

Spring Boot Spring WebFlux Kafka Redis GraphQL REST / μservices Node.js Next.js
[3] languages

Polyglot with focus on JVM, Go, and TypeScript.

Java Go TypeScript JavaScript Kotlin SQL
[4] cloud_devops

Infrastructure as code, on-premise and multi-cloud.

Kubernetes (on-prem + EKS) Terraform AWS GCP Azure GitLab CI / GH Actions APISIX
[5] observability_sec

Fast diagnosis and hardened applications.

Grafana Datadog New Relic Opsgenie OWASP Burp Suite
[6] testing_data

Automated quality from UI to database.

Playwright Selenium Jest JUnit Vitest PostgreSQL Oracle MySQL
~/infra $ kubectl get platform -o wide

Infrastructure

I built the team's on-premise platform from scratch: a declaratively managed Kubernetes cluster with an API gateway, automatic TLS, highly available data stores, and full observability. Everything animated below runs in production.

cluster — on-premise.svg
⎈ on-premise kubernetes observability scrape users cert-manager auto-tls private registry signed images api-gateway auth · rate-limit · tls service-a service-b service-c postgres HA · operator redis cache · queues prometheus grafana dashboards alerts ephemeral namespaces one per feature
~/deploy-platform $ ls escenas/ --play

The deployment platform

I designed and built the internal platform the whole team deploys with: from a push to production with ephemeral environments, managed secrets, a chat bot, and an audit trail for every step.

$ cat scenes/01-deploy.md

End-to-end deploys

A push triggers the whole pipeline: build with tests, signed image in the private registry, deploy to an isolated ephemeral namespace, automated smoke tests, and promotion to production.

scenes/01-deploy.md.svg
» every step lands in the audit trail git push build ci tests · lint registry signed image ephemeral ns isolated env smoke tests production
  • Every feature gets its own ephemeral environment with its own URL, created and destroyed automatically.
  • Nothing reaches production without passing the smoke tests in the ephemeral environment.
  • One-click rollback to the previous version, with full history.
$ cat scenes/02-secrets.md

Secrets management

Secrets live encrypted in a central store with role-based access and are injected into pods at deploy time. They never touch a repository and are masked in every log.

scenes/02-secrets.md.svg
✗ encrypted store role-based access platform runtime injection pod env · volumes logs •••••••• git never in the repo aes-256
  • Credential rotation without touching code or redeploying by hand.
  • Each service only sees the secrets it owns.
  • Audit trail of who accessed what and when.
$ cat scenes/03-bot.md

The deploy bot

A bot embedded in the team chat runs deploys, rollbacks, and status checks with one command. It validates permissions against the platform and replies with the rollout result in real time.

scenes/03-bot.md.svg
team chat ❯ /deploy api v1.2 ✓ deployed · 2 replicas ready bot checks permissions platform api kubernetes rollout also reports health & incidents
  • Deploying from chat removes friction: no consoles or dashboards to open.
  • Role-based permissions: everyone can only operate their own services.
  • Proactively reports deployment health incidents.
$ cat scenes/04-architecture.md

Internal architecture

The web UI and the bot talk to a central API; heavy jobs (builds, rollouts, smoke tests) run on async workers coordinated with Redis queues, deploying to both the on-premise cluster and cloud EKS.

scenes/04-architecture.md.svg
web ui bot api core workers redis queues k8s on-prem eks cloud audit log secrets registry
  • Multi-target: the same flow deploys to on-premise and to the cloud.
  • Async workers: the UI never blocks waiting for a rollout.
  • Every event lands in an immutable audit log.
~/method $ cat spec.md | agents --run --parallel

How I built it

Spec-driven development with AI agent orchestration: every feature starts as an executable spec that several agents implement in parallel, with deterministic quality gates before anything reaches production.

spec-driven — agents.svg
spec.md executable orchestrator agent-1 agent-2 agent-3 quality gates tests · lint · human merge→deploy deterministic gates: tests, architecture linting, and human review
~/quality $ npx playwright test && cat .gitlab-ci.yml

Quality & delivery

How I test and ship software: Playwright E2E against the real build and CI/CD pipelines with parallel quality, from commit to deploy.

$ cat scenes/05-e2e.md

E2E with Playwright

Smoke E2E tests run against the real production build served locally, with the backend mocked inside the browser itself: fast, deterministic, and independent of external environments. The full critical flow is verified in a real browser before every merge.

scenes/05-e2e.md.svg
localhost:4173/checkout cardholder card pay → ✓ payment approved production build served statically playwright chromium · 1 worker mocked backend intercepts network trace · screenshot only on failure ci green ✓ initial load ✓ form filled ✓ simulated payment ✓ confirmation
  • A separate layer from unit tests: it exercises the packaged build, not the source code.
  • Traces and screenshots are kept only on failure — light artifacts, full debugging.
  • The same tests gate the merge in CI: if the critical flow breaks, nothing lands.
$ cat scenes/06-pipelines.md

CI/CD pipelines

Frontend and backend share the same philosophy: quality in parallel (lint, unit, e2e, static analysis, and a coverage gate), unprivileged image builds, and deployment through the shared platform template — which also provides the rollback job.

scenes/06-pipelines.md.svg
frontend pipeline backend pipeline install per-branch cache lint unit tests e2e smoke build deploy compile static analysis coverage gate oci image no docker daemon deploy platform template deploy · rollback parallel jobs
  • Parallel quality jobs with per-branch caching: feedback in minutes, not hours.
  • Nothing deploys without passing the full quality stage.
  • Shared platform template: deploy and rollback are identical across every repository.
~/goals $ ./verify --all

Goals achieved

Measurable results of the infrastructure and the platform, verified in production.

verify — results.log
✓ 100% of the dev team ships daily through the platform
✓ E2E end-to-end auditable rollouts, with history and rollback
✓ min an ephemeral environment per feature, ready in minutes with its own URL
✓ TLS automatic certificates on every service in the cluster
✓ 24/7 metrics, dashboards, and alerts for every service in production
✓ 0 secrets in code repositories — encrypted runtime injection
✓ 1→N on-premise kubernetes cluster built from scratch and scaled
✓ 2 deployment targets with the same flow: on-premise and cloud
8 passed · 0 failed
~/career $ git log --graph --all

Journey

My story as a git log: the main branch is experience, learn is education. Click each commit for details.

main (experience) learn (education)

I lead the modernization of the payments layer and integrations with core business services (APISIX, secrets management, observability), using Redis for caching and idempotency in critical transactional flows.

  • Built the internal deployment platform adopted by the whole dev team: orchestrates on-premise Kubernetes and AWS/EKS, IaC, secrets, and change traceability across environments.
  • Standardized software delivery for multiple teams with end-to-end auditable rollouts, reducing friction and manual errors in production.
  • Drive AI adoption across the engineering cycle: assisted code review, alert analysis, and automation of repetitive ops tasks.
  • Support the evolution of the BSS and payments ecosystem with focus on resilience, scalability, and operational continuity.
APISIXRedisKubernetesAWS / EKSTerraformPayments

Cloud computing certification with AWS and Azure: architecture, managed services, and multi-cloud best practices.

  • Cloud architecture design and multi-cloud deployment strategies.
AWSAzure

Built backend and front-end solutions with Go, Node.js, TypeScript, and Next.js to automate internal flows and improve the experience of users and ops teams.

  • Integrated observability and incident tooling (Datadog, New Relic, Grafana, Opsgenie), cutting diagnosis and response times.
  • Worked on high-traffic services using Redis as distributed cache, session storage, and rate limiting to protect critical APIs.
  • Collaborated on AI automations for alert analysis and ticket generation, improving team productivity.
  • Applied security practices across the dev cycle: validations, reviews, and testing for sensitive applications.
GoNode.jsTypeScriptNext.jsRedisDatadogGrafana

Systems engineering degree pursued in parallel with my professional career, with real software projects.

  • Ticket management system for airport operations.
  • Gym membership management app with payments and tracking.
  • Dynamic library using the ChatGPT API to automate SEO generation for websites.
JavaGoPythonTypeScriptGoogle Cloud

Intensive full-stack bootcamp with modern technologies and agile methodologies.

  • Multiple full-stack projects with React, Node.js, and PostgreSQL; REST APIs and agile teamwork.
ReactNode.jsPostgreSQLTypeScript

Software and hardware technical support, partner-company tickets, and remote-connection solutions.

  • Reduced system downtime through proactive maintenance and monitoring; documented technical procedures.
LinuxmacOSNetworking
~/projects $ ./run --featured

Projects

Real production systems that demonstrate architecture, applied AI, and engineering judgment.

turenta-ai — pipeline.log CREATOR OPEN SOURCE

TuRenta AI

turenta.tax ↗

Open-source platform that automates income tax filing in Colombia (form 210): AI agents extract data from tax reports and certificates, interview the user, and a 100% deterministic tax engine computes the return — in a domain where a hallucination is a legal problem.

  • Hexagonal architecture with boundaries enforced by ESLint and architecture tests.
  • Golden test that reproduces a real tax return line by line as an accuracy guarantee.
  • Async workers with Redis for queues, rate limiting, and sessions.
TypeScriptNext.jsTurborepo / pnpmPostgreSQLRedisPlaywrightDockerGitHub Actions
$ tail -f agents.log
01
playwright → dian.gov.co ✓
Connects to the DIAN (tax authority) and auto-downloads reports, certificates, and filings.
02
llm.extract(docs) ✓
Agents extract structured data with a double read of every value.
03
human.confirm(values) ✓
Guided interview: every extracted value is confirmed before use.
04
tax_engine.compute(210) ✓
100% deterministic engine with rules that cite the law — zero hallucinations.
» system principle: AI reads, code calculates
WOM · INTERNO

Deployment platform

Internal platform adopted by the entire dev team: orchestrates deployments to on-premise Kubernetes and AWS/EKS, manages infrastructure as code, secrets, and change traceability across environments, with end-to-end auditable rollouts.

KubernetesAWS / EKSTerraformGitLab CIIaC
FULL-STACK

Feedback360

Complete professional feedback platform: teams with visibility levels (public, private, corporate), real-time notifications, Google login and OTP auth, goal management, and an admin dashboard.

ReactNode.jsExpressMongoDB
$ locale --list
es_CO
Spanish · native
pt_BR
Portuguese · advanced
en_US
English · professional
$ cert --verify ✓
Cloud Computing — AWS & Azure
Universidad de los Andes · 2025
~/contact $ ssh kevin@bayterx.com

Let's talk

Looking for an AI Engineer who can also run payments, Kubernetes, and observability in production? Reach out.

EMAILkevin@bayterx.com LINKEDINlinkedin.com/in/bayterx GITHUBgithub.com/kevinbayter
new-message.txt