Backend Engineering
Designing, developing, and maintaining backend applications, APIs, data models, background processing, and integrations.
- Ruby
- Ruby on Rails
- Sidekiq
- Redis
- MySQL
- REST APIs
Software Engineer focused on backend architecture, reliable systems, infrastructure, and technical leadership.
grafana · sentry · cloudwatch
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.
A working set of capabilities built across application development, infrastructure, operations, and engineering teams.
Designing, developing, and maintaining backend applications, APIs, data models, background processing, and integrations.
Designing and operating AWS environments for containerized applications: compute, networking, databases, deployment automation, and production operations.
Understanding complex applications, evolving legacy systems, evaluating architectural trade-offs, and improving maintainability.
Monitoring application behavior, analyzing logs, troubleshooting production issues, and improving operational visibility.
Improving code quality, development workflows, testing strategies, technical documentation, and delivery processes.
Supporting engineering teams, coordinating technical work, establishing standards, facilitating technical decisions, and improving collaboration.
Working stack
Established areas of experience. Explorations and emerging interests are listed separately below.
Ruby · Ruby on Rails · Sidekiq · Redis · MySQL · REST APIs · Background jobs · Application architecture · API integrations
AWS · ECS / Fargate · EC2 · RDS / Aurora · Application Load Balancer · CloudFront · Docker · Linux · Fly.io · CI/CD and deployment automation · Infrastructure operations
Grafana · Sentry · Prometheus · VictoriaLogs · Quickwit · CloudWatch Logs · Application monitoring · Log analysis · Production troubleshooting · Performance investigation
Git · GitHub · Code review · Testing · Technical documentation · Release coordination · Architecture decisions · Technical debt management · Engineering workflows
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.
Architecture, backend, infrastructure, and reliability.
Technical decisions, standards, quality, and delivery.
Technical coordination, collaboration, and knowledge sharing.
Technical coordination of approximately six developers, alongside hands-on backend and infrastructure work.
systems / engineering / peopleGeneralized case studies from professional experience: context, decisions, trade-offs, and lessons learned without confidential details.
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
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.
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
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.
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
Engineering lessons
Observability is a design constraint, not a dashboard project. A team needs evidence it can trust before it can change production safely.
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
Engineering lessons
Reliability is not in the happy path. It comes from understanding what happens when something fails.
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
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.
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
Understand the business problem, existing architecture, and operational constraints before introducing changes.
Prefer maintainable solutions and explicit trade-offs over unnecessary abstraction and complexity.
Deployment, monitoring, reliability, and operational maintenance are part of building software, not separate responsibilities.
Documentation, knowledge sharing, technical alignment, and clear communication are fundamental engineering practices.
I enjoy exploring technologies and tools that challenge existing ways of building software and improve how engineers work.
Exploring the BEAM ecosystem and what changes when concurrency and fault tolerance are first-class concerns.
Using coding agents and assistants as engineering leverage: faster exploration, better review habits, and clearer documentation.
Removing repetitive operational work with explicit, observable automation instead of hidden glue.
Improving the feedback loop: local environments, tooling, scripts, and the small details that compound.
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.
I’m interested in discussing software architecture, backend engineering, infrastructure, technical challenges, and opportunities to build better systems.