Backend & Distributed Systems Engineer
Designing reliable, event-driven systems at scale.

I am a backend engineer focused on distributed systems, event-driven architecture, and scalable infrastructure.

My work centers around designing resilient systems that handle high-volume workflows, real-time processing, and operational monitoring at scale. I care deeply about correctness, reliability, performance, and clean architectural boundaries.

I have built:

• Queue-driven incident management platforms
• Distributed monitoring systems across 1,000+ sites
• Real-time notification pipelines with rate limiting and idempotency guarantees
• Event-integrated Jira and Slack automation systems
• Relational and analytical data models for operational visibility

I enjoy solving infrastructure-aware backend problems that sit at the intersection of software engineering, systems design, and operational reliability.

Designed and implemented a containerized, queue-driven incident management system using:

• Node.js & TypeScript
• RabbitMQ & BullMQ
• Redis
• MySQL
• Docker & AWS Lambda

Key characteristics:

• Reliable message acknowledgment flows
• SLA-based prioritization
• Fault-tolerant distributed processing
• Idempotent job handling
• Controlled concurrency patterns

The system powers near real-time operational dashboards tracking:

• Incident lifecycle states
• Queue health metrics
• Velocity and performance indicators

Engineered a monitoring system validating script installations across 1,000+ sites.

Core design decisions:

• Job chunking to prevent infrastructure overload
• Queue-based orchestration for scalable processing
• Controlled execution frequency
• Concurrency limits with backpressure handling
• Real-time result propagation through event pipelines

This system feeds downstream services with live operational status and alert signals.

Built a scalable notification engine using:

• RabbitMQ for event transport
• Redis for rate limiting and idempotency
• Configurable trigger rules
• Slack integrations for operational visibility

Design principles:

• Rate-limited event firing
• Duplicate event protection
• Downstream-safe propagation
• Clear separation of event ingestion and notification logic

Strong focus on data correctness and performance:

• Normalized relational schemas (MySQL, PostgreSQL)
• Complex joins & aggregation queries
• Index optimization and execution plan tuning
• Incremental data models
• SCD Type 2 history tracking
• Cumulative & reduced-grain fact tables

Designed data systems that support:

• Near real-time dashboards
• Historical state reconstruction
• Operational analytics

I optimize for:

• Correctness before convenience
• Explicit data flows
• Idempotent operations
• Observable systems
• Infrastructure-aware design
• Failure-aware architecture

Distributed systems should be:

• Predictable
• Traceable
• Rate-controlled
• Resilient under load

Languages

• TypeScript
• Python
• Golang
• SQL

Backend & Messaging

• RabbitMQ
• BullMQ
• gRPC

Databases

• MySQL
• PostgreSQL
• MongoDB
• Redis

Infrastructure

• Docker
• Kubernetes
• Terraform
• AWS
• Ansible

• Distributed Incident Management Platform
• Site Health Monitoring System (1K+ sites)
• Notification Engine with Controlled Trigger Frequency
• Slack Bot Integrations for Operational Alerting
• AWS Auto Scaling + ALB Infrastructure via Terraform
• Analytical Data Models with Incremental & SCD2 Design
• Go gRPC API (Protocol Buffers)

• Distributed systems architecture
• Backend platform engineering
• Event-driven design
• Infrastructure automation
• Reliability engineering
• Systems performance optimization

• President, Association of Computer Engineering Students (KNUST)
• Engineering project lead during academic capstone
• Advocate for structured design documentation and technical clarity

• LinkedIn: https://linkedin.com/in/jonathan-a-attoh
• GitHub: https://github.com/engattoh

“Design systems that remain correct under load, clear under failure, and predictable under growth.”