Manuel Bauka - DevOps Engineer

Overview

Cloud-focused DevOps engineer (mid-level) specializing in Terraform-driven AWS infrastructure and ECS deployments. The strongest proven skill is building modular, production-oriented Terraform and environment separation as shown by terraform-wordpress-modules/environments/prod/main.tf and terraform-wordpress-modules/modules/wordpress/main.tf. There is limited evidence of advanced SRE practices such as SLO/burn-rate alerting, chaos testing or thorough unit/integration test coverage, and there are insecure plaintext credentials present in docker-compose which indicate gaps in secrets discipline.

Timeline

Cloud & DevOps Engineer · Middle

Freelance · Freelance

Dec 2021 to Present 4 Years 11 Months Pembroke Pines Partially remote

Designed and provisioned AWS infrastructure for portfolio applications using Infrastructure as Code with Terraform and CloudFormation, including networking and identity components. Built CI/CD pipelines with GitHub Actions and Docker to automate build, test, and deployment workflows to AWS, enabling safer release rollbacks. Implemented monitoring with CloudWatch dashboards, logs, metrics, and alarms, and extended observability to Kubernetes using Prometheus, Grafana, and Alertmanager via Helm. Developed full-stack apps using React, Node.js, and Python from code through cloud deployment.

Terraform

CloudFormation

IAM

Amazon ECS

AWS Lambda

API Gateway

Amazon CloudWatch

GitHub Actions

Docker

Prometheus

Grafana

Alertmanager

Helm

Kubernetes

React.js

Node JS

Python

Universidad Central Marta Abreu de Las Villas (UCLV)

Bachelor's Degree · Chemical Engineering

1996–2001 Santa Clara, Cuba

Projects

Kubernetes Observability Stack

Implemented a Kubernetes observability stack using kind and Helm to deploy Prometheus, Grafana, and Alertmanager. Added metrics components such as node exporter and kube-state metrics to support visibility across multiple namespaces and pods. Delivered an IaC-driven, one-command deployment approach for repeatable monitoring.

Serverless API on AWS

Designed a serverless API using AWS Lambda and API Gateway, backed by DynamoDB and configured to follow least-privilege access principles. Used IaC modules to keep the infrastructure consistent across environments. Focused on reliable API behavior and maintainable deployment practices.

Containerized App CI/CD Pipeline

Created an automated CI/CD workflow using GitHub Actions and Docker to build, test, and deploy a containerized application. Included deployment support for AWS ECS with rollback capability and environment-specific configuration. Emphasized safer release management and reproducible build and deployment steps.

Multi-Tier AWS Infrastructure

Built a multi-tier AWS environment using Terraform, including VPC networking, EC2 and ECS setup, IAM roles, and CI/CD pipeline scaffolding. Implemented a reusable, repeatable infrastructure structure aimed at reducing drift through IaC state management. Focused on secure and scalable deployments for production-style workloads.

Technical skills

Languages

4

Python

Node JS

JavaScript

Bash

DevOps

19

Kubernetes

Amazon CloudWatch

Amazon ECS

AWS

AWS Lambda

GitHub Actions

Grafana

API Gateway

Terraform

Prometheus

Docker

CloudFormation

Helm

Alertmanager

IAM

AWS Fargate

Amazon S3

Docker Compose

Amazon EC2

AI/ML

3

LLM

Claude

Anthropic

Databases

4

ElasticSearch

PostgreSQL

MySQL

DynamoDB

Other

13

React.js

Boto3

Flask

Express

React Native

GitHub

Containers

Git

Linux

Rest API

CI/CD

Databases

Least Privilege

Senior DevOps Engineer Confidence: High Cloud Architect

Cloud-focused DevOps engineer (mid-level) specializing in Terraform-driven AWS infrastructure and ECS deployments. The strongest proven skill is building modular, production-oriented Terraform and environment separation as shown by terraform-wordpress-modules/environments/prod/main.tf and terraform-wordpress-modules/modules/wordpress/main.tf. There is limited evidence of advanced SRE practices such as SLO/burn-rate alerting, chaos testing or thorough unit/integration test coverage, and there are insecure plaintext credentials present in docker-compose which indicate gaps in secrets discipline.

CI/CD Pipelines

5/10

Automated build and deploy

Practical CI/CD engineering with multi-job GitHub Actions including test/lint/security jobs, terraform-plan in PR, ECR build-and-push and deployment steps; lacks advanced reusable workflows, artifact signing, or sophisticated gating/rollback automation in the pipeline itself.

Evidence

inventory-dashboard/.github/workflows/deploy.yml: full multi-job pipeline (test, lint, security, terraform-plan, deploy-dev)

inventory-dashboard/.github/workflows/deploy.yml: terraform-plan job that comments PR and uses setup-terraform

inventory-dashboard/scripts/deploy.sh: build_and_push_images and deploy_services steps and image tag storage for rollback

Infrastructure as Code

6/10

Managing servers with code

Clear, versioned Terraform with reusable modules, environment separation and a production S3 backend with DynamoDB locking, lifecycle controls and instance refresh strategies; demonstrates state handling and modularization across environments.

Evidence

terraform-wordpress-modules/environments/prod/main.tf: S3 backend with dynamodb_table for locking

terraform-wordpress-modules/modules/wordpress/main.tf: module composition and templatefile usage for user_data

inventory-dashboard/terraform/main.tf: modular infrastructure, random_password resource and aws_ssm_parameter usage for secrets

Containerization & Orchestration

4/10

Working with containers

Good containerization practices (multi-stage Dockerfiles, non-root user, HEALTHCHECKs) and basic Kubernetes manifests with resource requests/limits and a ServiceMonitor; missing advanced orchestration controls like PDBs, affinity/topologySpread, tuned probes beyond defaults or progressive delivery tooling.

Evidence

inventory-dashboard/backend/Dockerfile: multi-stage build, non-root user, HEALTHCHECK

k8s-monitoring-stack/k8s/flask-app.yaml: Deployment with resource requests/limits and ServiceMonitor endpoint

k8s-monitoring-stack/app/Dockerfile and app/main.py: simple metrics endpoint and /metrics for Prometheus

Observability & Monitoring

4/10

Watching system health

Observability is explicitly implemented with Prometheus rules, ServiceMonitor, Helm kube-prometheus-stack values and Grafana configuration; alerts are sensible but there is no evidence of SLO/burn-rate alerting, alert routing policies or alert inhibition rules coded here.

Evidence

k8s-monitoring-stack/alerts/prometheus-rules.yaml: PodCrashLooping and NodeMemoryPressure rules

k8s-monitoring-stack/k8s/flask-app.yaml: ServiceMonitor exposing /metrics

k8s-monitoring-stack/helm/prometheus-stack/values.yaml: Prometheus retention and Grafana admin config

Reliability & Incident Response

6/10

Keeping systems up

Reliability-oriented configuration is present: ECS deployment circuit breaker with rollback, deployment health check grace periods, autoscaling policies and a scripted rollback mechanism that stores previous image tags in SSM; this shows operational thinking on rollback and graceful updates.

Evidence

inventory-dashboard/terraform/ecs.tf: aws_ecs_service backend with deployment_circuit_breaker and health_check_grace_period_seconds

inventory-dashboard/scripts/deploy.sh: store_previous_tag and rollback_deployment functions using SSM

terraform-wordpress-modules/modules/compute/main.tf: instance_refresh preferences and deregistration_delay for graceful termination

Cloud & Cost Optimization

5/10

Smart use of the cloud

Cloud and cost practices include autoscaling, ECR lifecycle policies, use of FARGATE_SPOT capacity providers and environment-specific sizing in production; however explicit cost measurements, rightsizing analysis or spot eviction handling patterns are limited.

Evidence

inventory-dashboard/terraform/ecs.tf: aws_ecs_cluster_capacity_providers with FARGATE_SPOT

inventory-dashboard/terraform/main.tf: aws_ecr_lifecycle_policy resources

inventory-dashboard/terraform/ecs.tf: aws_appautoscaling_policy backend_cpu for target tracking

Expertise

Cloud Platforms & Architecture· Senior

CI/CD & Pipeline Automation· Middle

Infrastructure as Code· Senior

Kubernetes Ecosystem· Middle

Technologies

Containers

Terraform· since 2021

Docker Compose

GitHub Actions· since 2021

Prometheus· since 2021

AWS· since 2024

Kubernetes· since 2021

Grafana· since 2021

AWS Fargate

Alertmanager· since 2021

Amazon ECS· since 2021

Amazon CloudWatch· since 2021

Cloud· mentioned only

DevOps· mentioned only

Docker· mentioned only

IaC· mentioned only

Recommendations

Lead development of Terraform module-driven AWS infrastructure and environment promotion pipelines (remote state, locking, lifecycle policies).
Design and implement CI/CD pipelines that include reusable workflows, deploy gates and signed artifacts for production releases.
Harden operational security by replacing plaintext secrets with SSM/Secrets Manager or SOPS and add automated secret scanning to pipelines.
Expand observability by codifying SLOs/burn-rate alerts and adding alert routing/inhibition rules and runbook links to alerts.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

k8s-monitoring-stack inventory-dashboard terraform-wordpress-modules

Middle AI/ML Engineer Confidence: Medium LLM Engineer

LLM engineer (middle) focused on building event-driven, serverless pipelines that integrate hosted LLM inference into a job-matching workflow. The strongest proven skill is building resilient AWS Lambda-based ingestion, scoring, and notification pipelines integrating Anthropic Claude and DynamoDB, evidenced by src/collector/handler.py and src/scorer/handler.py. There is no evidence of custom model training, experiment tracking, or large-scale performance tuning in the public code.

Model Architecture & Training

2/10

How well models are designed and trained

Lightweight LLM integration and prompt engineering against a hosted Anthropic Claude model; no custom model training, schedules, or optimization of training/architectures.

Evidence

job-agent/src/scorer/handler.py: SYSTEM_PROMPT (structured scoring prompt for Claude)

job-agent/src/scorer/handler.py: score_job - calls anthropic.Anthropic.messages.create and parses JSON response

Data Pipeline & Feature Engineering

5/10

How data is prepared for models

Robust event-driven ingestion pipeline with multi-source scraping, normalization, deduplication and DynamoDB item shaping; clear defensive filtering and conditional writes.

Evidence

job-agent/src/collector/handler.py: collect_jobspy, collect_jsearch, collect_ats and passes_title_filter - multi-source ingestion and filtering

job-agent/src/shared/__init__.py: JobPosting.content_hash and to_dynamo_item - deterministic dedupe and DynamoDB-safe item shaping

Experimentation & Evaluation

1/10

How results are measured and tested

Minimal experimentation and evaluation artifacts; unit tests present for core helpers but no experiment tracking, held-out evaluation pipelines or metrics for model behavior.

Evidence

job-agent/tests/test_shared.py: unit tests for content_hash, to_dynamo_item and ScoreResult.validate

MLOps & Deployment

4/10

How models are shipped to production

Production-pattern serverless deployment design using DynamoDB streams, SSM for secrets, Lambda handlers and SES notifications; good operational considerations but limited model lifecycle tooling.

Evidence

job-agent/src/scorer/handler.py: DynamoDB stream processing and mark_scored/mark_score_failed integration

job-agent/src/shared/__init__.py: get_ssm_parameter and get_table - runtime AWS integrations for SSM and DynamoDB

Computational Efficiency

3/10

How efficiently computing resources are used

Practical efficiency steps for serverless cold-starts and throughput: lazy imports, ThreadPoolExecutor for concurrency, and lru_cache for reused artifacts; no GPU/quantization/throughput profiling.

Evidence

job-agent/src/collector/handler.py: lazy import of jobspy and ThreadPoolExecutor use to parallelize sources

job-agent/src/scorer/handler.py: @lru_cache on load_resumes and get_anthropic_client to avoid repeated work

Research Depth & Innovation

1/10

Depth of research and new ideas

No original research, novel algorithms or custom model implementations; the work focuses on production integration and prompt design rather than research depth.

Evidence

job-agent/src/scorer/handler.py: SYSTEM_PROMPT is a practical prompt engineering artifact but not a research implementation

Expertise

LLM· Middle

Industries

Artificial Intelligence· Middle

Software· Middle

Technologies

Databases

MySQL

PostgreSQL

Claude

DynamoDB

Helm· since 2021

CloudFormation· since 2021

CI/CD

Git

Docker· since 2021

ElasticSearch

LLM

AWS Lambda· since 2021

Amazon EC2

Anthropic

GitHub

Amazon S3

IAM· since 2021

API Gateway· since 2021

Linux

Recommendations

Develop production LLM inference services with cost and latency monitoring and budgeted retry/backoff logic, extending the scorer/handler.py flow to include request budgeting and exponential backoff.
Add structured model-evaluation and experiment tracking (WandB or MLflow) and automated A/B evaluation for prompt variants and scoring thresholds.
Build RAG or agentic workflows that include retrieval, caching, and guardrails for long-form reasoning to expand beyond single-call scoring.
Implement observability and drift monitoring for LLM outputs and business metrics, integrating metrics and alerts from the notifier and monitoring stack into a centralized dashboard.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

job-agent k8s-monitoring-stack

Middle Backend Developer Confidence: Medium API Engineer

Backend engineer (Senior-level score 3.5) specializing in serverless, event-driven AWS pipelines and LLM-based scoring workflows. The strongest proven skill is building a production-minded serverless pipeline connecting a collector, DynamoDB-backed stream scorer with Anthropic, and an SES notifier, as evidenced by job-agent/src/collector/handler.py, job-agent/src/scorer/handler.py, and job-agent/src/shared/__init__.py. There is limited public evidence of advanced distributed-systems design, infra-as-code, schema migrations, or load-testing artifacts.

API Design

5/10

How well APIs are designed

API and integration design shows idempotency via content-hash and conditional writes, DynamoDB stream parsing and a consistent JSON contract from the LLM, but lacks formal API versioning or explicit error-code surface for clients.

Evidence

job-agent/src/shared/__init__.py:JobPosting.content_hash and to_dynamo_item (idempotency + item shape)

job-agent/src/shared/__init__.py:put_job_if_new (conditional put with ConditionExpression)

job-agent/src/scorer/handler.py:extract_job_from_stream_record and _ddb_val (DynamoDB stream to job shape)

Data Layer & Database

6/10

Working with databases

Data layer shows deliberate DynamoDB design: conditional writes, TTL, item-size truncation, GSI query usage and careful update expressions, with pagination in scans; no relational migration history (DynamoDB used).

Evidence

job-agent/src/shared/__init__.py:to_dynamo_item (ttl, description truncation to avoid DynamoDB limits)

job-agent/src/shared/__init__.py:put_job_if_new (ConditionExpression to achieve idempotent insert)

job-agent/src/shared/__init__.py:mark_scored and query_scored_above_threshold (UpdateExpression, GSI query using status-fit_score-index)

Scalability & Performance

5/10

Handling load and speed

Scalability and performance considerations are present: parallel source collection, lazy imports to reduce cold starts, caches for resume and client, and timeouts on external HTTP calls, but no systematic backoff/retry policy or measured optimization artifacts.

Evidence

job-agent/src/collector/handler.py:use of concurrent.futures.ThreadPoolExecutor and lazy import of jobspy to limit cold-start overhead

job-agent/src/scorer/handler.py:load_resumes and get_anthropic_client decorated with lru_cache to reuse warm container state

job-agent/src/collector/handler.py:timeouts on urllib.request.urlopen and rate-limiting sleep in collect_jsearch

System Architecture

6/10

Overall system structure

Clear, purposeful service decomposition into collector, scorer, and notifier Lambdas with a shared helpers module and environment/SSM-driven configuration, reflecting a considered event-driven architecture.

Evidence

job-agent/src/collector/handler.py:collector lambda - ingest and normalize pipeline

job-agent/src/scorer/handler.py:scorer lambda - DynamoDB stream consumer and LLM integration

job-agent/src/notifier/handler.py:notifier lambda - GSI query and SES delivery; shared module centralizes common utilities

Security & Auth

5/10

Protecting data and access

Security-aware patterns exist: secrets fetched from SSM, HTML escaping before rendering, and input validation on LLM results, but no advanced secrets rotation evidence, explicit token lifecycle management, or dependency-audit artifacts.

Evidence

job-agent/src/shared/__init__.py:get_ssm_parameter (fetch secrets from SSM)

job-agent/src/scorer/handler.py:get_anthropic_client (retrieves API key from SSM)

job-agent/src/notifier/handler.py:render_digest_html and render_digest_text use html.escape to avoid injection in emails

Reliability & Observability

5/10

Stability and monitoring

Observability and reliability are deliberately implemented with structured JSON logging, defensive try/excepts, failure marking paths, and some graceful fallbacks, though retry/backoff and circuit-breaker patterns are not systematically applied.

Evidence

job-agent/src/shared/__init__.py:configure_logging and log_json (structured JSON logs)

job-agent/src/collector/handler.py:_safe wrapper used to isolate source failures and extensive log_json calls

job-agent/src/scorer/handler.py:mark_score_failed and logging around LLM calls to capture and persist failures

Expertise

Backend AI & LLM· Middle

Microservices & API Architecture· Middle

Python· Middle

Industries

Software· Middle

Technologies

Python· since 2021 · Middle

Rest API

Flask

Boto3

Stack· mentioned only

Recommendations

Develop serverless event-driven microservices that integrate LLMs and durable stores (DynamoDB stream consumers, idempotent writes).
Harden production readiness: add structured retry/backoff with jitter for external HTTP and LLM calls and introduce circuit-breaker patterns where appropriate.
Expand observability and operational tooling: expose metrics, add distributed tracing and alerting, and add documented runbooks for common failure modes.
Work on infra-as-code and CI/CD manifests (Terraform/CloudFormation) and run automated load tests to validate scaling characteristics.

Repositories

The developer's experience in this domain has been verified based on AI analysis of the following repositories:

job-agent k8s-monitoring-stack portfolio-website

Job preferences

Work permits: United States
Employment type: Freelance