ALAA
BADAWII

Software & AI Engineer
Agentic Systems • Grounded RAG Pipelines • High-Reliability Python Backends

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.

📍 Cairo, Egypt 🪖 Military Service: Completed ✅ Available for AI & Backend Roles

Who I am

About Me

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.

Areas of interest
Software Engineering AI Engineering Python RAG Agentic Systems Backend Architecture AI Reliability
1,100+
Automated Tests · Quizey
3
Flagship Projects
7
Professional Certificates

What I bring

Skills & Technologies
🧠
AI Engineering & RAG
RAG PipelinesHybrid Retrieval (Dense + BM25)Reciprocal Rank Fusion (RRF)Cross-Encoder RerankingVector Databases (Chroma)EmbeddingsPrompt EngineeringLLM IntegrationStructured OutputsCitation Validation
🤖
Agentic Systems & Automation
AI AgentsMulti-Agent SystemsLangChainLangGraphCrewAIn8nTool CallingReAct & ReflectionStateful WorkflowsAgent MemoryConditional RoutingAgentic RAG
⚙️
Backend Engineering & Databases
PythonSQLFastAPIFlaskRESTful APIsSQLAlchemySQLModelPydanticJWT & RBACAsync ProgrammingDependency InjectionDatabase DesignAtomic TransactionsConcurrency & IdempotencyMySQLPostgreSQLMongoDBSQLiteRedis
🛡️
Reliability, Evaluation & DevOps
pytest (Unit, Integration, API Testing)Retrieval Evaluation (Precision@K, MRR, Recall)Groundedness & Answer CorrectnessLLM-as-a-JudgeDeterministic ValidationDocker & Docker ComposeAWS EC2Linux / BashGit & GitHubPostman
Code Quality
& Best
Practices
Documentation and readability

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.

Modular and maintainable architecture

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

My Projects
Flagship
In Progress • 1,100+ Automated Tests
Quizey — AI-First Assessment & Training Platform
1,100+ Automated Tests RBAC & JWT Auth Atomic Concurrency Fail-Closed Redis Auth

AI-first assessment and personalized training platform engineered to diagnose learner skill gaps and enforce high-integrity, concurrency-safe examination workflows.

  • Engineered a modular Python backend with Role-Based Access Control (RBAC), copy-on-write versioning, immutable exam snapshots, and configurable workflows.
  • Built concurrency-safe grading and strict one-time submission guarantees using database-backed idempotency keys, atomic transactions, and frozen attempt papers.
  • Implemented Redis-backed JWT revocation with expiration-aware TTLs and fail-closed security behavior during cache outages.
  • Backed by a suite of 1,100+ automated unit and integration tests covering auth, RBAC, race conditions, data integrity, and MySQL migrations.
PythonSQLAlchemyMySQLRedisJWTRBACpytestConcurrencyIdempotencySystem Design
Autonomous AI Agent
LinkedIn Personal Branding Agent — AI Content & Publishing Automation
Stateful RAG Workflow Chroma + SQLite Automated Guardrails

Persistent, scheduled AI agent workflow for grounded LinkedIn content generation, validation, and automated publishing.

  • Built a stateful agentic pipeline combining RAG retrieval, LLM reasoning, and deterministic pre-publish validation.
  • Implemented a Chroma vector knowledge base paired with SQLite-backed state tracking for content intent, publication history, and strict duplicate prevention.
  • Integrated automated LinkedIn publishing with multi-layer safeguards, error handling, and real-time status notifications.
PythonAI AgentsRAGChromaDBSQLiteLLM WorkflowsAutomationAPI Integration

More repositories, labs, and experiments live on GitHub →

Signature experience

The Engineering Behind the Intelligence

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.

  1. · Intelligence
  2. · Architecture
  3. · Reliability
  4. · Real Value

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.

Engineering Philosophy

The principles behind every system I ship.

P1

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.

P2

Deterministic beats hopeful

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.

P3

Test the failure path

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.

P4

Measure, don't demo

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.

P5

Design for the next engineer

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.

P6

Own the whole path

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.

Inside My Engineering Mind

Real constraints from real projects. What would you decide?

The Builder's Log

Decisions, trade-offs, and outcomes from the work itself.

Showing 7 of 7 entries

AI & RAG

Leading a team under a 40-hour clock

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.

Outcome 85% Precision@1 · 87.9% MRR · 130/130 traceable citations
Backend · Reliability

The submission that arrived twice

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.

Outcome One-time submission guarantee · race conditions covered in the 1,100+ automated tests
Backend · Reliability

Choosing to fail closed

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.

Outcome Fail-closed security behavior · cache-outage scenarios are in the test suite
AI & RAG

Grounded or nothing

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.

Outcome 100% grounded responses · 130/130 candidate answers traceable to sources
AI · Reliability

Building the measuring stick

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.

Outcome 85% P@1 · 75% Answer Correctness baseline · every change measured against it
Learning

Twelve months at the foundations

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.

Outcome ALX Certified Backend Software Engineer · Sep 2024
Learning

Rebuilding RAG by hand

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.

Outcome 7 of 10 courses complete · expected Nov 2026

"I don't just build systems that work. I build systems I can explain, test, trust, and improve."

Flagship project — journal

Building Quizey V2
1,100+
Automated tests
Phase 1
✅ Complete
Phase 2
🔶 In progress

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.

Complete
Phase 1 — Foundation

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.

FlaskSQLAlchemyJWT AuthCopy-on-Write1,100+ Tests

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

Experience & Growth

Two experiences that shaped how I build: leading delivery under pressure, and a rigorous engineering foundation to grow from.

CR
Team Lead (Team of 5) — Clinical RAG Hackathon Project
Creativa AI Hackathon · Banha, Egypt
Team leadership Aug 2026
Outcome 85% Precision@1 · 87.9% MRR · 100% grounded responses · 130/130 traceable citations
  • Led a 5-person cross-functional team through an intensive 40+ hour hackathon, coordinating backend, data engineering, and frontend delivery of a clinical RAG system for NICE NG217.
  • Directed the technical architecture and hybrid retrieval optimizations the team shipped — dense + BM25 fusion, reranking, and deterministic citation validation.
AL
Backend Engineering Trainee
ALX Africa · Remote
Professional training Aug 2023 – Sep 2024
Outcome ALX Certified Backend Software Engineer · Sep 2024
  • Completed ALX's 12-month Software Engineering programme — nine months of full-stack foundations, then three months of backend specialization.
  • Engineered backend applications with Python, Flask, SQLAlchemy, MySQL, REST APIs, authentication, Redis caching, and automated test suites.
  • Applied production practices across relational database design, Linux administration, Git workflows, debugging, and application architecture.
Collaboration
&
Communication
Aligning with business objectives

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.

Communicating technical ideas clearly

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.

Problem-
Solving &
Logical
Thinking
Analyzing requirements and constraints

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.

Debugging and optimization

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

Education & Certificates
Education
Certifications & Professional Training
Additional certificates
Containerization and Kubernetes for DevOpsPackt · Aug 2026
Build RAG Applications: Get StartedIBM · Aug 2026
Develop Generative AI Applications: Get StartedIBM · Jul 2026
DevOps Foundations & Development WorkflowPackt · Jul 2026
DevOpsManara · Jul 2026
Node.js Backend Development ProgramManara · Apr 2026
AI Fluency Framework & FoundationsAnthropic · Jul 2026
ALX Professional FoundationsALX Africa · May 2026
Other credentials
McKinsey Forward ProgramMcKinsey & Company · Jul 2026
Speak English ProfessionallyGeorgia Institute of Technology · Jun 2026
PyMongo — AdvancedEDUCBA · Jun 2026
Build with AI: Masr EditionITI & Google
AiCE — AI Career EssentialsALX Africa · Apr 2026
Currently growing
LearningIBM RAG & Agentic AI — remaining certificate courses
LearningFastAPI & Backend Development
LearningEnglish Communication for Tech Professionals — Arizona State University
Up NextProduction deployment & observability for current projects.

Looking ahead

The Next 12 Months

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.

🎯
Backend Depth

Deepen architecture, API design, data systems, reliability, and testing across the backend work I do — from Flask and FastAPI to production-oriented data modeling.

🤖
AI Systems

Move from AI fundamentals into practical agentic and RAG systems — agents, tool calling, evaluation, and grounded generation built on a first-principles understanding.

🏗️
Production Engineering

Close the gap between building and shipping: Docker, CI/CD, cloud deployment, Kubernetes, observability, and reliable AI infrastructure.

📈
Portfolio & Product

Keep evolving Quizey and the other engineering projects into systems worth using — reliable, tested, and deployable — not just demos.

💼
Career & Education

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.

SOFTWARE
ENGINEER
Get In Touch

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.