Skip to content
Mateo Peláez ArandaSoftware Engineer & Technical Lead
Mateo Peláez ArandaSoftware Engineer & Technical Lead

Mateo Peláez Aranda, Software Engineer & Technical Lead. Building reliable systems.
Engineering with purpose.

Software Engineer focused on backend architecture, reliable systems, infrastructure, and technical leadership.

10 years in software engineeringBackend · Cloud · Observability
system.map
reference
  1. edgeweb · mobile · api
  2. applicationruby · rails · rest
  3. cloudaws · ecs · fargate
  4. workerssidekiq · redis
  5. datamysql · redis
observabilityacross every layer

grafana · sentry · cloudwatch

backend · infrastructure · leadership10y
01About

About Mateo Peláez Aranda.

I am Mateo Peláez Aranda (also written Mateo Pelaez Aranda), a software engineer and technical lead working at the intersection of software development and system operations.

Over the years, I have worked across backend applications, infrastructure, production environments, and engineering teams.

I am particularly interested in understanding how systems behave in real-world conditions, identifying architectural weaknesses, simplifying complexity, and improving the way software is built and maintained.

I believe good engineering is about making thoughtful decisions, understanding trade-offs, and creating systems that other engineers can confidently work with.

02Expertise

Where I create value.

A working set of capabilities built across application development, infrastructure, operations, and engineering teams.

01

Backend Engineering

Designing, developing, and maintaining backend applications, APIs, data models, background processing, and integrations.

  • Ruby
  • Ruby on Rails
  • Sidekiq
  • Redis
  • MySQL
  • REST APIs
02

Cloud Infrastructure & DevOps

Designing and operating AWS environments for containerized applications: compute, networking, databases, deployment automation, and production operations.

  • AWS
  • ECS / Fargate
  • EC2
  • RDS / Aurora
  • ALB
  • CloudFront
  • Docker
  • CI/CD
03

Systems Architecture

Understanding complex applications, evolving legacy systems, evaluating architectural trade-offs, and improving maintainability.

  • Legacy systems
  • Trade-offs
  • Maintainability
  • Incremental change
04

Observability & Reliability

Monitoring application behavior, analyzing logs, troubleshooting production issues, and improving operational visibility.

  • Grafana
  • Sentry
  • Prometheus
  • Log analysis
  • Troubleshooting
05

Engineering Practices

Improving code quality, development workflows, testing strategies, technical documentation, and delivery processes.

  • Code review
  • Testing
  • Documentation
  • CI/CD
  • Technical debt
06

Technical Leadership

Supporting engineering teams, coordinating technical work, establishing standards, facilitating technical decisions, and improving collaboration.

  • Technical planning
  • Code review
  • Engineering standards
  • Team coordination

Working stack

Established areas of experience. Explorations and emerging interests are listed separately below.

Backend Engineering

Ruby · Ruby on Rails · Sidekiq · Redis · MySQL · REST APIs · Background jobs · Application architecture · API integrations

Cloud Infrastructure & DevOps

AWS · ECS / Fargate · EC2 · RDS / Aurora · Application Load Balancer · CloudFront · Docker · Linux · Fly.io · CI/CD and deployment automation · Infrastructure operations

Observability & Performance

Grafana · Sentry · Prometheus · VictoriaLogs · Quickwit · CloudWatch Logs · Application monitoring · Log analysis · Production troubleshooting · Performance investigation

Engineering Practices

Git · GitHub · Code review · Testing · Technical documentation · Release coordination · Architecture decisions · Technical debt management · Engineering workflows

03Ownership

Responsibility across systems, engineering, and people.

Technical ownership is not a title. It is the willingness to connect architecture, delivery, and the team that has to live with the result.

I work across three layers at once: the systems in production, the engineering practices that keep changes safe, and the people who need enough context to make good decisions.

01

Systems

Architecture, backend, infrastructure, and reliability.

  • Application architecture
  • Backend and data models
  • AWS infrastructure
  • Production reliability
02

Engineering

Technical decisions, standards, quality, and delivery.

  • Technical planning
  • Code and design review
  • Engineering standards
  • Deployment workflows
03

People

Technical coordination, collaboration, and knowledge sharing.

  • Team coordination
  • Architecture discussions
  • Documentation
  • Knowledge sharing

Technical coordination of approximately six developers, alongside hands-on backend and infrastructure work.

systems / engineering / people
04Selected work

Engineering in practice.

Generalized case studies from professional experience: context, decisions, trade-offs, and lessons learned without confidential details.

01

Evolving a legacy Rails application

Modernizing a long-lived Rails application in controlled steps, without pausing the business that depends on it.

Context

A mature Ruby on Rails application carrying years of accumulated dependencies, integrations, and operational expectations. Framework and runtime upgrades had been deferred while product work took priority.

Challenge

Each version jump changes runtime behavior, gem compatibility, and background processing. The application had to keep serving traffic throughout, and the team needed to separate real incompatibilities from upgrade noise.

Constraints

Production continuity, dated third-party integrations, limited maintenance windows, and no budget for a dedicated rewrite. Every change had to be reversible and observable in production.

Technical approach

Map the dependency graph, upgrade in small verified steps, replace abandoned gems, run upgrade branches alongside product work, and compare behavior before and after each release using existing monitoring and logs.

Trade-offs

A rewrite would remove legacy constraints but freeze product delivery and concentrate risk. Incremental upgrades preserve continuity but stretch the effort across releases and leave some debt in place.

Technologies

  • Ruby
  • Ruby on Rails
  • Bundler
  • MySQL
  • Sidekiq
  • Redis
  • Production monitoring

Engineering lessons

The hard part of modernization is not the target version. It is understanding what the running system depends on and keeping it operable while it changes.

02

Cloud Infrastructure & Application Delivery

Designing and operating the AWS environment behind a containerized production application, from networking and deployments to database operations.

Context

A containerized Rails application running on AWS: ECS services with Fargate tasks behind an Application Load Balancer, CloudFront in front of public traffic, RDS for persistent data, and Docker images promoted through a CI/CD pipeline.

Challenge

Application code, container images, networking, deployment strategy, and database operations all had to move together. A change in one layer could surface as latency, failed health checks, or a deployment that could not roll back cleanly.

Constraints

Production traffic could not stop for releases, the database was stateful, security and network rules were strict, and infrastructure had a real cost. Deployment windows and operational ownership limited how much could change at once.

Technical approach

Treat delivery as one system: build immutable images, promote them through the pipeline, deploy with health checks and a rollback path, keep application and infrastructure configuration explicit, and route logs and metrics to a shared observability layer.

Trade-offs

Managed services reduce operational burden but limit control. Blue/green deployment lowers release risk but doubles resources during rollout. More automation pays off over time but has to be built and maintained.

Technologies

  • AWS
  • ECS / Fargate
  • EC2
  • RDS / Aurora
  • Application Load Balancer
  • CloudFront
  • Docker
  • ECR
  • CodePipeline
  • CodeBuild
  • CodeDeploy
  • CI/CD

Engineering lessons

Application delivery is not a deployment step at the end. It is a design problem that spans application architecture, infrastructure, networking, and data.

03

Observability and production reliability

Turning production symptoms into evidence by correlating metrics, logs, and exceptions across application, infrastructure, and data layers.

Context

Containerized Rails workloads on AWS with background processing, a relational database, and traffic passing through load balancers and a CDN.

Challenge

Alerts described symptoms rather than causes. The same latency pattern could come from a slow query, a saturated worker queue, a failing integration, or an infrastructure change.

Constraints

Production traffic could not be paused for experiments. Log volume carried storage and query costs, and noisy alerts eroded trust in monitoring.

Technical approach

Standardize on a small set of signals, correlate CloudWatch metrics with application logs, use Sentry for exceptions, keep dashboards close to the services they describe, and turn recurring failures into runbooks.

Trade-offs

More instrumentation improves diagnosis but adds cost and ownership. Fewer alerts reduce fatigue but risk missing early warning. The balance was reviewed as the system and the team changed.

Technologies

  • Grafana
  • Sentry
  • AWS CloudWatch
  • Prometheus
  • VictoriaLogs
  • Quickwit
  • Log analysis
  • Production troubleshooting

Engineering lessons

Observability is a design constraint, not a dashboard project. A team needs evidence it can trust before it can change production safely.

04

Backend processing and system reliability

Operating asynchronous Rails workloads on Sidekiq, Redis, and MySQL without losing sight of failure modes.

Context

Rails applications that rely on background jobs, Redis, and MySQL for work that cannot live inside a request: integrations, notifications, imports, and scheduled processing.

Challenge

Jobs fail differently from web requests: retries, duplicates, delayed queues, database pressure, and external side effects that are not always idempotent.

Constraints

Job volumes and external integrations impose limits. A poorly designed retry can duplicate effects, and an uncontrolled queue can degrade the whole application.

Technical approach

Understand the execution lifecycle and failure modes; design idempotent jobs, bound retries, separate queues by criticality, monitor latency and errors, and protect database and Redis health.

Trade-offs

Retries improve resilience but require idempotency. Synchronous processing simplifies the flow but couples request latency. More parallelism improves throughput but competes for the same resources.

Technologies

  • Ruby on Rails
  • Sidekiq
  • Redis
  • MySQL
  • Background processing
  • Database operations
  • Application reliability

Engineering lessons

Reliability is not in the happy path. It comes from understanding what happens when something fails.

05

Technical leadership and engineering workflows

Coordinating technical work for a team of about six developers while staying hands-on across backend, infrastructure, and delivery.

Context

Technical coordination of a team of approximately six developers, alongside responsibility for planning, quality, architecture discussions, and cross-cutting technical decisions.

Challenge

Align the team’s work, sustain quality, and balance delivery against technical debt and changing priorities, while keeping enough context in one place to make decisions quickly.

Constraints

Team size, delivery expectations, varied experience, and the time available for review and documentation shape what can be sustained.

Technical approach

Make work visible through technical planning, review code and architecture decisions, write down standards, keep documentation close to the systems it describes, and improve workflows based on recurring friction.

Trade-offs

More standards improve consistency but can reduce autonomy. Investing in documentation and review slows short-term delivery and usually sustains it over time.

Technologies

  • Technical planning
  • Code review
  • Architecture discussions
  • Engineering standards
  • Documentation
  • Development workflows

Engineering lessons

Technical leadership is about helping a team make better decisions and consistently deliver maintainable software, not about owning every decision.

These are generalized case studies based on professional experience. They intentionally omit confidential company information, customer names, internal architecture, and production details. No business metrics are claimed.

05Approach

How I approach engineering.

Good engineering is a series of deliberate trade-offs, not a search for the perfect tool.

I optimize for systems that are understandable, operable, and honest about their constraints. That usually means choosing the simplest option that holds, writing the decision down, and making the next change easier.

Systems over silver bullets

01

Understand the system before changing it.

Understand the business problem, existing architecture, and operational constraints before introducing changes.

02

Simplicity is an engineering decision.

Prefer maintainable solutions and explicit trade-offs over unnecessary abstraction and complexity.

03

Production is part of the product.

Deployment, monitoring, reliability, and operational maintenance are part of building software, not separate responsibilities.

04

Better systems require better teams.

Documentation, knowledge sharing, technical alignment, and clear communication are fundamental engineering practices.

06Currently exploring

Always learning. Always building.

I enjoy exploring technologies and tools that challenge existing ways of building software and improve how engineers work.

Functional programming

01

Exploring the BEAM ecosystem and what changes when concurrency and fault tolerance are first-class concerns.

  • Elixir
  • Phoenix
  • LiveView

AI-assisted development

02

Using coding agents and assistants as engineering leverage: faster exploration, better review habits, and clearer documentation.

  • Claude Code
  • OpenCode
  • MCP
  • Coding agents

Automation and workflows

03

Removing repetitive operational work with explicit, observable automation instead of hidden glue.

  • n8n
  • Workflow automation
  • AI agents

Developer productivity

04

Improving the feedback loop: local environments, tooling, scripts, and the small details that compound.

  • Developer tooling
  • Local environments
  • Engineering workflows

Recently, my attention has been focused on functional programming, AI-assisted development, automation, and developer productivity.

These are ongoing interests and explorations, not claims of production expertise.

07Contact

Let’s build something meaningful.

I’m interested in discussing software architecture, backend engineering, infrastructure, technical challenges, and opportunities to build better systems.