Engineering
Backend-first development with Java, Spring Boot, Python & Node.js.
Ahmedfig. 01 · portrait
Open to workCairo, Egypt · Remote
Backend-Focused Software Engineer
I build backend systemsfrom first sketchto running production.
Backend-focused software engineer building reliable systems, AI-powered services, and production-oriented applications — from first sketch to running production.
- Client
- Web App
- Backend API
- Database
- AI Services
- Deployment
system online · 6 nodes
How I Build
Backend-first · AI-assisted · Production-focused
AI Workflows
AI-assisted planning, building, testing & review.
Real Systems
Business platforms, intelligent applications, APIs & automation.
Selected Work
Featured projects shaped by real problems — from first sketch to running production.
The person
About
“I care about what happens when software leaves the development environment and becomes a real system.”
I'm a backend-focused software engineer. I like taking a problem from idea to architecture, implementation, and deployment — and I care as much about what happens after launch as before it. That's when software stops being code and becomes a system that has to keep working.
Backend engineering is where I'm strongest: APIs, services, databases, architecture, data flow, security, performance, reliability, deployment. I'll work across the stack when a project needs it, but my center of gravity is the part that runs.
I use AI heavily in my workflow. It helps me move faster — exploring, prototyping, reviewing, debugging — but it doesn't replace engineering judgment. I understand, review, and own what gets built.
Backend-firstSystems thinkingAI-accelerated
Expertise
Engineering domains as a connected system. Select a domain to see the technologies behind it and the context in which I use them.
The core of every system I build.
- Java / Spring Boot — dependable services and enterprise backends.
- Python / FastAPI — typed APIs and AI-adjacent services.
- Node.js — real-time and glue services between systems.
- REST APIs — clear, predictable contracts between parts.
- Auth & validation — identity and input enforced at the boundary.
- Background processing — work that shouldn't block the request.
Where a system succeeds or fails.
- Service boundaries — each responsibility clear and owned.
- Data flow — know how data moves before wiring endpoints.
- Caching — Redis for the hot paths that need it.
- Asynchronous processing — decoupling work that shouldn't be synchronous.
- Reliability — designing for failure, not around it.
Features that ship, not demos.
- Face recognition — TAMINI's face-vector matching pipeline.
- Vector embeddings & similarity — images → vectors → matches.
- FastAPI AI services — Python AI services wired into the backend.
- Image & file processing — real media flowing through the pipeline.
- AI-assisted workflows — AI in how I build, not just what I build.
Deployment is part of engineering.
- Docker — environments that match everywhere.
- AWS & serverless — cloud services when they earn their place.
- Render — RETAILA runs on it in production.
- Linux — where most of what I build actually runs.
- Deployment — shipping, monitoring, and iterating on live systems.
Where the system's truth lives.
- PostgreSQL — the default when data must be right.
- Redis — progress, caching, and session state.
- MongoDB — when the document shape is the product.
- Schema design & indexing — decisions that compound for years.
- Transactions & consistency — data that stays correct under load.
RETAILA is the proof.
- POS & business workflows — sales, inventory, orders, refunds, expenses.
- Ledger-based money — financial events as an immutable history.
- Multi-tenant architecture — five businesses, data isolated per tenant.
- Business rules — pricing, credits, and vendor flows as logic.
- Financial integrity — consistency across every money movement.
How I actually work day to day.
- AI-assisted development — AI across exploration, code, review, and docs.
- Code review — my judgment, applied to every diff.
- Testing — confidence that lets me change things safely.
- Git & GitHub — collaboration and history.
- Automation — repeated steps become scripts, not rituals.
The path
Engineering Journey
From writing code, to building systems that keep working — faster, with AI-assisted engineering.
01
Learning to build
Started with programming fundamentals — Java first, then Python, then JavaScript. Before anything else, I learned how software is actually constructed: how code becomes a program, and how a program becomes something people can use.
JavaPythonJavaScript
02
Building real systems
Moved from isolated applications toward APIs, databases, and backend architecture — systems that carry real business logic. This is where I started caring about how the pieces fit together, not just whether each piece runs.
APIsDatabasesBackend architecture
03
Engineering systems
Started thinking beyond individual features: architecture, data flow, failure, security, performance, scalability, deployment. This is where RETAILA and TAMINI happened — systems built to keep working after they ship.
ArchitectureData flowDeployment
04
AI-accelerated engineering
Today I combine traditional software engineering with AI-assisted development — and I build AI-powered services into real products. AI is leverage; the engineering judgment and the ownership stay mine.
AI-assistedAI-powered servicesReview & ownership
AI Engineering
“AI is part of how I build software — in the products I ship, and in how I engineer.”
Two sides of the same tool. I build AI-powered features into real products — TAMINI's face-recognition pipeline, for example, where a FastAPI service turns face images into vectors and matches them against missing- and found-person reports.
And I use AI throughout my own workflow: exploration, implementation, debugging, review, documentation, prototyping. It makes me faster. It doesn't make the decisions — I review, understand, and own the systems it helps me build.
- AI-powered servicesface recognition and matching built into real products
- Vector embeddings & matchingimages → vectors → similarity search
- Service-to-service AIPython AI services wired into the backend
- Architecture explorationAI used to map options before committing
- Implementationdrafts quickly, reviews every line that ships
- Debugging & reviewAI as a second pair of eyes on my own judgment
- Documentation & prototypingfrom idea to working proof fast
Standards
Philosophy
The standards I hold every system to.
Understand the Problem First
Technology is secondary to understanding what the system actually needs to accomplish.
Keep Boundaries Clear
Good architecture makes every responsibility understandable and owned.
Prefer Simplicity
Don't introduce complexity just because a system could theoretically need it.
Build for Reality
Software should survive real usage, failures, changing requirements, and deployment.
Data Matters
Good systems depend on good data models, consistency, and deliberate database design.
Reliability Over Hype
A system that works consistently is worth more than one that merely looks impressive.
Learn by Building
I learn technologies deeply by using them to solve real problems.
AI With Judgment
AI accelerates my workflow, but I remain responsible for understanding and reviewing what gets built.
Things I've Built
Three systems that show how I approach a problem — and that they keep working after they ship.
01
Backend Team Lead
2025
TAMINI / طمني
Case studyAn AI-powered platform that connects missing-person and found-person reports using facial recognition and matching.
- Led a 3-person backend team inside a 7-member project — architecture, task execution, code review, and technical decisions.
- Designed the backend architecture and personally implemented roughly 50% of the backend.
- Wired Spring Boot, Node.js real-time services, and a FastAPI face-recognition pipeline together into one system.
Spring BootFastAPINode.jsPostgreSQLDocker
02
Independent design & build
2025
LUDER
Case studyA reusable file upload and download engine for secure, resilient large-file transfers — shared infrastructure I reuse across projects.
- Chunked, resume-safe uploads and downloads.
- AES-CBC encryption at rest and ClamAV malware scanning before storage.
- Reused across roughly three projects as shared file-transfer infrastructure.
JavaSpring BootRedisPostgreSQLClamAV
03
Sole Developer & Architect
Jun 2026 – present
RETAILA
Case studyA production management platform for small businesses that centralizes inventory, sales, vendor payments, credits, refunds, and financial operations.
- Used by 5 businesses — roughly 1,200 products across 13 modules.
- Designed and implemented the complete backend and database schema for the core business workflows.
- Engineered cash-ledger orchestration so sales, payments, credits, and refunds stay financially consistent.
- Deployed the production system on Render.
JavaSpring BootPostgreSQLRedisDocker
Let's build something that works in the real world.
ahmedwalid9876543@gmail.com
Open to remote & freelance engineering work
Cairo, Egypt · Remote