Open to work - backend, platform, AI and full stack engineering
Badda, Dhaka, BangladeshAsia/Dhaka (UTC+6)
I work as aFull Stack Software Engineer
Roles: Full Stack Software Engineer, Backend Engineer, AI Engineer, DevOps Engineer, Software Engineer.
I build the software businesses run on - the platforms that take the money, count the stock, record the hours and reach the customers. My job is making sure those systems stay up, stay correct and stay affordable as they grow, and I stay responsible for them right through to production.
Core stack: Python, Django, FastAPI, PostgreSQL, Redis Streams, Celery, pgvector, Docker, Traefik, AWS, Next.js, React Native, LangGraph, Scrapy, Playwright, Prometheus, Grafana, Cloudflare, PgBouncer, WebSocket.
Job titles slice the same work differently. Pick the one you are hiring for and the diagram, the evidence and the tools all re-focus around it - each written as what it produces, not just what it uses.
Hover a nodeEvery block here is something I have built, broken and fixed in production. Hover one for a plain-language explanation of what it does.
Give me a business problem described in plain language and I hand back a working, deployed feature - the database behind it, the interface people click, the automation that runs overnight, and the release that puts it live. Fewer hand-offs means fewer misunderstandings and a shorter path from decision to revenue. Four products in production, three of them serving several customer companies from one system.
I model the product the way the people running it describe it, so a request like "let branch managers see last month, not last year" is a small change rather than a rewrite. The API is versioned, documented and permission-aware, so other teams build on it without waiting on me.
Dashboards, onboarding flows and admin screens in React, Next.js and React Native - one backend serving all of them. Half the maintenance cost, and no drift where the app tells a customer something different from the website.
I sit in the requirements conversation, turn it into a data model and a delivery plan, then stay responsible for it in production. Being in that loop end to end is why I now lead junior engineers through the same process.
Sales figures, attendance records, stock counts, payments - these are the numbers a business argues about. My job is making sure they are right when two people act at the same second, when a server dies halfway through a job, and when the same instruction arrives twice. Customers never notice this work; they only notice its absence.
Jobs are claimed on a timed lease instead of being handed out and forgotten. If the machine processing one crashes, the job returns to the queue automatically and another picks it up. The business impact: a crash costs a few minutes of delay, not a lost day of processing and a manual clean-up.
Every step in a pipeline retries on failure, backs off when a source is struggling, and parks whatever it truly cannot handle where a human can see it. Each step is written so a repeated message produces the same result - which is why a retry never double-charges a customer or double-counts a shift.
Each client company gets its own isolated database schema and its own domain, with per-branch access inside it. Isolation is enforced by the database rather than by a filter a developer has to remember - so the worst kind of incident in shared software becomes structurally impossible rather than merely unlikely.
SSLCommerz, Stripe, Twilio, Google OAuth, AWS SES and ZKTeco biometric hardware, each behind a common interface. Changing provider - for price, coverage or an outage - is a configuration change instead of a project.
Most AI demos work once and fall over in production, because a language model is confident even when it is wrong. I build the boundary around it: the model suggests, the application checks and decides. That is the difference between a feature a company can actually launch and one that stays a prototype. My research background is NLP - a Bengali–English word alignment thesis - and my production work is making models behave like dependable software.
An AI assistant can read a request like "tag everyone who opened the March campaign as warm" and prepare the change - but it never writes to the database itself. The application validates the proposal and applies the same permission rules a human would face. A misunderstood instruction becomes a rejected suggestion, not a corrupted customer list.
Every model response is validated against a declared structure. Anything malformed is retried with correction rather than saved and discovered later by a customer. Bad AI output stops at the door instead of quietly polluting reports.
Model calls route across multiple providers with automatic failover, so a rate limit or outage slows the pipeline instead of taking the feature offline. Token spend is recorded per call and per document, so "what does this feature cost us per month?" is a query rather than a guess.
Semantic search over stored content, with cheap filters in front so the expensive comparison only runs where it can change the answer. Users find the right item when they do not know the exact words; the infrastructure bill stays flat.
One system handling both languages end to end - extraction, duplicate detection and search - which matters for any product serving a market where customers switch scripts mid-sentence.
Teams postpone releases because releases hurt - the site blinks, someone has to babysit it, and rolling back is a panic. I remove that cost. New versions go out while customers keep using the product, a bad build never receives traffic, and going back to the previous version is one command. Shipping stops being an event and becomes a habit, which is how features reach customers faster.
The new version starts and proves itself healthy before a single user is sent to it; the old one is retired only afterwards. No maintenance windows, no 502 errors, no out-of-hours deployments - and a rollback is redeploying the previous version, deliberately boring.
Automated pipelines provision, migrate and release each customer environment across VPS, AWS and other clouds. Onboarding stops competing with engineering time, which makes selling to the next customer cheaper than selling to the last one.
Connection pooling, caching and query work come before bigger servers. On one platform that carried growth to 10,000+ daily users without an infrastructure upgrade - the cheapest capacity is the capacity you stop wasting.
Dashboards track the few numbers that actually predict an incident - queue backlog, stage latency, error rates. The team hears about a slowdown from a chart, not from a support ticket or an angry tweet.
Tagging a release triggers everything else: tests, version numbering, changelog, and publishing to every distribution channel. Nothing depends on someone remembering a step at 11pm.
Software gets expensive when only one person understands it. I build so the opposite is true: shared building blocks that make the fifth feature cheaper than the first, architecture written down where the team can read it, and juniors coached until they can make the decision without me. The commercial version of that sentence is lower key-person risk and a shorter ramp-up for every new hire.
Shared components and common layers extracted across projects, so each new requirement reuses proven parts instead of adding another variation to maintain. Delivery gets faster over the life of a product rather than slower.
Leading junior developers, reviewing designs before code is written, and running knowledge-sharing sessions - so good decisions get repeated by the team instead of re-explained by me.
Architecture notes and decision records kept next to the code. A new engineer becomes productive in days rather than weeks, and nobody has to reverse-engineer why something was built the way it was.
Data Preprocessors on PyPI: strict versioning, automatic changelogs and reproducible builds, published to three channels. When strangers depend on your code, sloppy releases become other people's outages - a discipline I now apply to internal systems too.
Each of these is a case study: the business problem, the decision I made, and the result it produced. Every one opens with a plain-language summary, then goes as deep as you want to go.
Reads the news in Bangla and English all day, removes the duplicates, and answers questions about what it found.
Software that runs a whole gym chain - memberships, billing, staff and door access - for 10,000+ people a day.
Sends hundreds of thousands of emails without wrecking the sender's reputation - and lets you manage contacts by talking to it.
Removed a hardware purchase from the sales conversation - old fingerprint terminals now work with a cloud product.
Intern to senior in four years across three companies - each step earned by shipping something the business could point at.
TechForing Ltd.Jan 2026 - Present
Leading the technical direction of a multi-tenant SaaS platform. The theme of the role is removing the things that slow a product company down: a codebase too tangled to change safely, customer onboarding that costs a day of engineering time, and repetitive work that should never have needed a person.
TechForing Ltd.
Owned two things customers judge a business platform on - whether it reaches people, and whether it counts their hours correctly - plus the payment and identity integrations everything else depended on.
Nimusoft Technologies Ltd.
Moved from executing tickets to shaping systems: sitting with leadership while requirements were still vague, turning them into an architecture, and staying accountable for the result across several products.
Nimusoft Technologies Ltd.
Django application work with a deliberate bias toward building things once and reusing them - the habit that made later projects cheaper.
NSU StartUps Next
Built the incubator's own platform while advising the startups inside it - a fast education in shipping something useful while the requirements change every week.
Write-ups on decisions I had to make, defend and then live with in production. Each opens by explaining the problem in plain language - and what it costs a business - before the technical detail begins.
A routine deploy costs about a minute of failed requests, because "update" quietly means stop-then-start. Here is the pipeline that ships to a single server without a customer ever seeing an error - no Kubernetes, no second load balancer, and a rollback that is the same path as the deploy.
ReadA till that stops working when the internet does is a till that loses money. Here is the contract that lets a desktop point of sale keep selling through an outage and reconcile exactly once when the connection returns - without ever charging a customer twice or losing a sale from the books.
ReadSplitting a large codebase is usually sold as a rewrite and delivered as a disaster. Here is how to do it piece by piece while the product keeps shipping to customers - plus an honest account of what independent deployment actually costs you in return.
ReadSenior backend, platform, AI or full stack engineering - full time or contract. Tell me what the system does and where it currently hurts, and I will usually have something concrete to say straight back. I reply to everything, normally within a day.