Build boring before impressive
The data model, the integrity layer, and the tests come before any intelligent feature. Intelligence built on a shaky foundation is a demo — the boring work is what makes the impressive part survive production.
Building production-grade AI applications and resilient backend architectures in Python. I bridge LLM workflows, multi-agent systems, and hybrid RAG pipelines with strict engineering guarantees— deterministic evaluation, atomic transactions, concurrency control, and 1,100+ automated tests.
Who I am
Hi, I'm Alaa Badawii — a software and AI engineer passionate about building reliable AI-powered products. I combine software engineering and AI to build complete applications: backend systems, databases, APIs, and AI capabilities, working together. I care about the bigger picture — how everything should fit, and making sure the final product is reliable, useful, and valuable to its users.
For me, building AI products isn't just about making the AI work — it's about building the whole product around it, with the right checks and safeguards to protect users, earn their trust, and deliver tangible value.
Recently I led a five-person team at the Creativa AI Hackathon, where we built a clinical RAG system on the NICE NG217 guideline — working across system architecture, the FastAPI backend, hybrid retrieval, cross-encoder reranking, LLM generation, and evaluation — reaching 85% Precision@1, 87.9% MRR, and 130/130 traceable citations. My foundation comes from the ALX Software Engineering Program: nine months of full-stack training followed by three months of backend specialization, applied since through independent projects like Quizey, the AI-first assessment platform I'm currently developing.
I'm most drawn to RAG systems, AI agents, multi-agent workflows, AI application reliability, and backend architecture — products where software engineering and AI work together to create something distinctive. I'm always happy to connect with fellow engineers and people building interesting products.
What I bring
I write code that's built to last — clean, well-documented, and easy for any team member to pick up. Every function has a clear purpose, every module a clear boundary. I follow PEP 8, use meaningful naming conventions, and document public APIs thoroughly so future maintainers don't have to guess.
From Flask Blueprints and app factory patterns to layered MVC separation, I design backend systems with scalability in mind from day one. Features stay decoupled, dependencies stay manageable, and the codebase can grow without becoming a burden.
What I've built
End-to-end clinical RAG system engineered for the NICE NG217 medical guideline, combining dense retrieval and BM25 lexical search via Reciprocal Rank Fusion (RRF), cross-encoder reranking, and deterministic citation validation.
AI-first assessment and personalized training platform engineered to diagnose learner skill gaps and enforce high-integrity, concurrency-safe examination workflows.
Persistent, scheduled AI agent workflow for grounded LinkedIn content generation, validation, and automated publishing.
More repositories, labs, and experiments live on GitHub →
Signature experience
Making AI work is only the beginning. Making the whole system work reliably is the real engineering.
I care about what happens before, during, and after the AI generates an answer. The goal isn't just to make it work—it's to make it worth relying on.
Three connected chapters: the principles I design by, an interactive walkthrough of how I make engineering decisions under real constraints, and a running log of how those decisions played out on actual projects.
The principles behind every system I ship.
The data model, the integrity layer, and the tests come before any intelligent feature. Intelligence built on a shaky foundation is a demo — the boring work is what makes the impressive part survive production.
I don't trust prompts or clients to be correct. Citations are validated deterministically, submissions are guarded by idempotency keys and atomic transactions, and an answer either traces to its sources or it doesn't ship.
Race conditions, cache outages, expired tokens, failed migrations — that's where systems break. 1,100+ automated tests cover auth, RBAC, concurrency, and data integrity, with fail-closed defaults when a dependency disappears.
A demo proves a system can work once; an evaluation harness proves it keeps working. Retrieval quality (Precision@1, MRR, Recall) and generation quality (Groundedness, Answer Correctness) are measured, not assumed.
Clear module boundaries, explicit interfaces, meaningful names, documented APIs. From Flask blueprints to layered backends, the codebase has to grow without becoming a burden for whoever touches it next.
Building isn't done until it ships. Docker, CI/CD, Linux, and cloud deployment close the gap between a system that works on my machine and one that stays reliable in production.
Real constraints from real projects. What would you decide?
Decisions, trade-offs, and outcomes from the work itself.
Showing 7 of 7 entries
Coordinated a 5-person cross-functional team through an intensive 40+ hour hackathon to ship a clinical RAG system for the NICE NG217 guideline. The pivotal architecture decision: hybrid retrieval — dense vectors fused with BM25 via Reciprocal Rank Fusion and cross-encoder reranking — instead of betting the whole system on a single retrieval method.
When a student clicks submit twice — or a retry fires after a timeout — the exam must be graded exactly once. I placed the guarantee at the database level: database-backed idempotency keys, atomic transactions, and frozen attempt papers, so correctness never depends on the client behaving itself.
JWT revocation lives in Redis. When the cache is unreachable, do you fail open — letting requests through — or fail closed and reject them? We fail closed, with expiration-aware TTLs, because a few rejected requests cost far less than honoring a revoked token.
A clinical answer that sounds right but cites nothing is worse than no answer. Every generation passes a deterministic citation-validation gate: claims must map back to retrieved sources before the response is allowed to ship.
You can't tune what you don't measure. I built an evaluation harness covering retrieval (Precision@1, MRR, Candidate Recall) and generation (Groundedness, Answer Correctness, LLM-as-a-judge), so every pipeline change is compared against numbers instead of vibes.
ALX Africa's Backend Engineering specialization: Flask, SQLAlchemy, MySQL, REST APIs, authentication, Redis caching, and automated test suites — with Linux, Git, and relational database design as daily practice rather than side reading.
Working through the IBM RAG and Agentic AI Professional Certificate — rebuilding each hands-on project independently instead of copy-pasting: LangChain structured outputs, LlamaIndex retrieval with Chroma, and agentic workflows with LangGraph.
"I don't just build systems that work. I build systems I can explain, test, trust, and improve."
Flagship project — journal
Quizey started from a conviction: exams should do more than measure — they should improve learning. It's a backend exam and training platform where teachers create assessments, students take them with integrity, and grading is fast, consistent, and auditable. The product isn't exams — it's continuous, measurable learning improvement. I'm building it production-oriented: copy-on-write versioning, state machines, database-backed idempotency, fail-closed Redis JWT revocation, and audit integrity come before any intelligent feature — all backed by 1,100+ automated tests.
The core loop works end-to-end: create exams, publish them, take them, get graded. Copy-on-write versioning keeps published exams immutable. JWT auth secures every endpoint. 1,100+ automated tests verify the entire system — including state-machine subtests covering the attempt lifecycle. This is the solid foundation everything else builds on.
Taking the foundation toward production — the reliability, rich grading, and integrity tooling that real organizations need to trust their assessments. Implemented so far: attempt lifecycle (pause/resume, lazy expiry, telemetry), advanced grading (multi-select partial credit, weighted and bonus questions, manual grading with rubrics), assessment rules, and an integrity layer with database-backed idempotency keys, atomic transactions, immutable audit logging, and Redis-backed JWT revocation with expiration-aware TTLs and fail-closed security behavior during cache outages. Remaining: version management tooling, question banks, dashboards, platform services, and DevOps.
Intelligent question generation, personalized feedback, and adaptive learning paths — built on Phase 2's clean data and stable infrastructure. AI is not implemented in the current backend; it is deliberately planned only after the platform is reliable.
My philosophy: build boring before building impressive. The foundation, the data model, the integrity layer — that's what makes the intelligent features valuable later, not the other way around.
Professional development
Two experiences that shaped how I build: leading delivery under pressure, and a rigorous engineering foundation to grow from.
I don't just write backend code — I understand the product. I work closely with teammates to ensure every technical decision is grounded in real requirements, translating business goals into clean, reliable system behavior that actually serves users.
Whether writing clear API docs, explaining a database design in a team meeting, or flagging a potential bottleneck early — I make sure everyone stays informed and aligned, regardless of their technical background.
Before writing a single line of code, I break down the problem. I map out data flows, identify edge cases, and challenge assumptions. This upfront thinking prevents costly rewrites and ensures the solution actually fits real-world constraints — performance, scale, and maintainability included.
Bugs are inevitable — slow responses shouldn't be. I approach debugging methodically: reproduce, isolate, fix, verify. For performance, I profile before optimizing, focusing on query efficiency, session management, and caching where they matter most.
Credentials
Looking ahead
My focus over the next year is to become an engineer who can independently build, ship, and reliably operate AI systems — from backend foundations to production deployment. That means deepening backend engineering, moving from AI fundamentals into practical agentic and RAG systems, and closing the build-to-ship gap with Docker, CI/CD, and cloud infrastructure. Quizey stays at the center: a production-oriented platform I keep evolving into something people genuinely use.
Deepen architecture, API design, data systems, reliability, and testing across the backend work I do — from Flask and FastAPI to production-oriented data modeling.
Move from AI fundamentals into practical agentic and RAG systems — agents, tool calling, evaluation, and grounded generation built on a first-principles understanding.
Close the gap between building and shipping: Docker, CI/CD, cloud deployment, Kubernetes, observability, and reliable AI infrastructure.
Keep evolving Quizey and the other engineering projects into systems worth using — reliable, tested, and deployable — not just demos.
Continue pursuing backend and AI engineering opportunities that let me grow in a real-world environment, pairing practical experience with continued learning.
The goal isn't a job title or a tech stack — it's becoming an engineer who can independently build, ship, and reliably operate AI systems people actually rely on, while helping other engineers do the same.
Open to AI and backend engineering roles, freelance projects, and collaborations. Always happy to discuss new opportunities, technical challenges, or just connect. Reach out through any channel below — I usually respond within 24 hours.