Software Engineer | Backend Systems, APIs, and Automation

I build reliable backend systems for products that need to work at scale.

I’m Md. Banjir Ahammad, a software engineer focused on backend development, API design, and systems that stay maintainable as products grow. I work mainly with Laravel, MySQL, AWS, and Vue-based applications, building production-ready features, integrations, and automation workflows for real-world products.

View projects Read case study

GitHub LinkedIn [email protected]|Dhaka, Bangladesh

Portrait placeholder for Md. Banjir Ahammad

About

Building backend systems that are clear, stable, and ready to grow.

My work focuses on backend engineering: designing APIs, structuring application logic, improving system reliability, and integrating third-party services in a way that stays manageable over time.

I care about the parts of software that often matter most in production: data flow, failure handling, queues, retries, performance, and maintainable architecture. I enjoy turning complex requirements into systems that are easier to understand, safer to operate, and simpler to extend.

While I can work across the stack when needed, my strongest value comes from backend development and the engineering decisions that make products more dependable.

Operating principles

Prefer evidence over intuition for performance decisions.
Make failures explicit—logs, states, and user-visible honesty.
Keep boundaries boring and interfaces strict.

Skills

Technologies I use as a software engineer to design, build, and maintain production systems.

Backend Engineering

PHP
Laravel
MySQL
REST API Development
Queue-Based Processing
Third-Party Integrations

Software Architecture

Microservices Architecture
Service Boundaries
Modular System Design
Data Modeling
Caching Strategies
Event-Driven Workflows

Cloud and Infrastructure

AWS S3
AWS SQS
AWS SES
AWS EC2
AWS RDS
Deployment Workflows

Frontend

Vue.js
Nuxt.js
JavaScript
API-Driven Interfaces

Engineering Practices

Git
CI/CD
API Testing and Debugging
Logging and Monitoring
Performance Optimization

Featured projects

Architecture you can defend in a design review.

Themes aligned to real delivery: integrations, service boundaries, automation, and Laravel systems tuned for maintainability.

AI Provider Orchestration Layer

A resilient integration layer for an external image generation API—built for quotas, latency, and failure domains.

Details

Context: Product teams needed reliable image generation without turning the core monolith into a fragile integration knot. Upstream behavior could change quickly: rate limits, timeouts, and partial failures had to be first-class concerns.
Stack: LaravelQueuesMySQLRedis (optional pattern)AWS (S3 for assets)

Impact: Reduced operational toil from stuck jobs, improved predictability under upstream slowdowns, and made the integration maintainable as provider APIs evolved.

Microservices-Ready API Platform

Service boundaries, contracts, and deployment safety for a growing product surface area.

Details

Context: As client applications multiplied, the backend needed clearer ownership boundaries and safer evolution. The goal was pragmatic decomposition: services where it earned its keep, not microservices for aesthetics.
Stack: LaravelMySQLMessage-driven workflowsAWS primitivesREST

Impact: Faster iteration with fewer surprise regressions; teams could ship client features without constantly negotiating hidden shared state.

Internal Automation System

Scheduled workflows and guardrails that replace repetitive human checkpoints.

Details

Context: Several operational workflows were predictable but time-consuming—manual checks, recurring data hygiene, and follow-ups that did not need human judgment every time.
Stack: LaravelQueuesMySQLNotificationsInternal dashboards

Impact: Lowered recurring operational load and reduced human error windows—without hiding critical actions from review.

Production-Grade Laravel Application Suite

End-to-end product backend: authentication, billing touchpoints, integrations, and performance discipline.

Details

Context: A business needed a maintainable Laravel foundation that could grow—integrations, reporting hooks, and real traffic—without accruing silent technical debt.
Stack: LaravelMySQLRESTPayment APIsSMS providers

Impact: A codebase new engineers could navigate, integrations that failed safely, and measurable performance wins on critical queries.

Experience

Outcomes and ownership—not a generic responsibility list.

March, 2024 — Present

Mojaru

Senior Software Engineer · On Site

Shipped versioned HTTP APIs for web and mobile with production-grade error handling
Designed microservice boundaries that cut coupling and improved release safety
Integrated AI image generation with async workflows and retries and idempotency and quota-safe failures
Automated recurring work with scheduled jobs and internal tooling without raising incident risk
Hardened payment and SMS integrations with reliable webhooks and reconciliation
Improved database performance with indexing and profiling-backed query tuning
Refactored critical paths into smaller modules with clearer ownership and fewer surprises

Jan, 2023 — Feb, 2024

A.R Technologies Limited

Full Stack Developer · Remote

Delivered Laravel apps with disciplined routing validation services and maintainable migrations
Shipped REST APIs with consistent responses and solid authentication and clear client documentation
Built product features with thorough edge-case handling and trustworthy data integrity
Isolated failures across the app database and vendor integrations and fixed root causes

2019 – 2022

Education

B.Sc in Computer Science & Engineering

Central University of Science and Technology

CGPA 3.88/4.00

Case study

Async AI generation with production-grade failure handling.

A condensed walkthrough of how I think about vendor integrations: explicit states, idempotency, and operational visibility—without pretending distributed systems are easy.

Read the full case study →

<?php

namespace App\Http\Controllers\Api\V1;

final class GenerationController
{
    public function store(StoreGenerationRequest $request): JsonResponse
    {
        $intent = $this->generator->enqueue(
            idempotencyKey: $request->idempotencyKey(),
            payload: $request->validated(),
        );

        return response()->json([
            'data' => ['id' => $intent->publicId(), 'status' => $intent->status()],
        ], Response::HTTP_ACCEPTED);
    }
}

Illustrative structure—focused on how responsibilities split between HTTP ingress and asynchronous processing.

Writing

Notes on backends, APIs, and real systems.

View all articles →

2026-03-12

A Practical Laravel Query Performance Checklist

How I approach slow endpoints: measure first, then fix the right layer—indexes, N+1 calls, and transaction scope.

7 min read·LaravelMySQL

2026-02-26

REST API Design: Pragmatic Versioning and Error Semantics

Stable contracts reduce client breakage. Here is how I version endpoints and keep errors actionable without leaking internals.

8 min read·API designREST

2026-01-30

Microservices Boundaries and Operational Cost

Service splits only earn their keep when they improve velocity or isolation. I use a simple decision frame before decomposing.

9 min read·MicroservicesArchitecture

Consulting-shaped delivery

How I can help teams ship resilient backend work.

Positioned as senior engineering support—not a bargain marketplace listing. If your roadmap needs deep backend execution, this is the shape of the work.

API development

Versioned HTTP APIs, error semantics, auth flows—designed for multiple clients and long maintenance horizons.

Backend architecture

Service boundaries, data modeling, and integration seams that stay understandable as requirements shift.

Performance optimization

Measured improvements: query plans, indexing, hot-path shaping, and queue-driven offload where it fits.

Cloud deployment and integrations

AWS building blocks in real systems—storage, messaging, email—wired with operational safety.

Contact

Let's build something scalable together.

Have a system to build or optimize? If you need a backend engineer who cares about contracts, reliability, and measurable performance—send a concise note with context, constraints, and timelines.

Have a system to build or optimize? Let's talk.

[email protected]

Profile

GitHub

Repositories

Website

banjir-ahammad.com

Message

Send a message

Goes to [email protected]. With server email configured, it sends directly; otherwise your mail app opens with a draft.