Buildingthoughtful softwarefor the modern web.
I'm Mohamed Idbenouakrim — a software engineer focused primarily on backend development, turning fuzzy ideas into fast, reliable systems. Currently designing and shipping scalable APIs and services with Node.js, Python, and FastAPI, while still building seamless full-stack experiences with React when needed. Passionate about performance, clean architecture, and attention to detail.
/portrait.jpg — drop your photo here
MI · 2026
- Based in
- Casablanca, MA
- Focus
- Full-stack · Web
- Open to
- Remote & hybrid
- Languages
- EN · FR · AR
Engineer by craft, builder by instinct.
I write software the way I'd build a bookshelf — measure twice, sand the edges, and make sure it doesn't wobble. Most of my time is spent shipping web apps end-to-end: shaping the data model, sculpting the interface, and chasing the last 10ms of perceived performance.
I work best in small teams where the line between “design” and “engineering” is comfortably blurry. I'm equally happy debugging a gnarly SQL plan or arguing about button radii.
Outside of code: long walks, espresso, and writing about systems that quietly work well.
Systems built to scale.
Backend engineering with a focus on distributed systems, AI infrastructure, and fault-tolerant architecture.
AI Backend Platform
A scalable AI backend using FastAPI featuring AI document chat, vector search, RAG pipelines, Redis caching, Celery workers, streaming AI responses, async architecture, and full observability.
Natural language queries over documents via RAG
Chunk → embed → store → retrieve → generate loop
Qdrant cosine-similarity search on dense embeddings
SSE token streaming from OpenAI direct to client
Async task queue for ingestion and AI pipeline jobs
Distributed LRU cache for embeddings & completions
Stateless auth with access + refresh token rotation
Per-user AI token budgets and request throttling
End-to-end traces across API, workers, and AI calls
AI latency, token usage, pipeline throughput metrics
Parallel ingestion with chunking and batch embedding
Fully async FastAPI with non-blocking I/O throughout
- Batch embedding with OpenAI text-embedding-3 model
- RAG: retrieve top-k chunks → inject into prompt context
- Qdrant collections with payload filtering for multi-tenancy
- Prompt template engine with token budget enforcement
- Fully async FastAPI with SQLAlchemy async sessions
- Celery + Redis broker for background AI task processing
- SSE streaming endpoint that forwards OpenAI token stream
- Multi-file parallel ingestion with chunk overlap strategy
- Stateless API layer — horizontally scalable by default
- Celery worker pool auto-scales based on queue depth
- Redis Cluster-ready with TTL-based cache eviction
- Qdrant collection sharding for vector-at-scale
- AI call latency, token count, and error rate metrics
- Traces span: HTTP request → Celery → OpenAI → response
- Structured JSON logs with correlation IDs end-to-end
- Grafana dashboards pre-built for AI pipeline SLOs
Go API Gateway
An API Gateway in Go featuring reverse proxying, JWT authentication, Redis-based distributed rate limiting, load balancing, circuit breakers, OpenTelemetry tracing, and Prometheus metrics — built on clean architecture principles.
Transparent forwarding with upstream header injection
Stateless auth with RS256/HS256 signing & key rotation
Redis-backed distributed token bucket — per client IP
Round-robin & weighted strategies across upstreams
Hystrix-pattern fault isolation with half-open recovery
Distributed traces via W3C TraceContext propagation
RED metrics (rate, errors, duration) exported per route
Multi-stage alpine build — image < 20 MB at runtime
Domain, application & infrastructure layers enforced
Composable handler pipeline with context propagation
SIGTERM handler drains all in-flight requests safely
Correlation IDs injected at edge, logged end-to-end
- Clean architecture with strict layer boundaries
- Domain-driven design & interface abstractions
- Dependency injection for testability
- Middleware composability via handler chains
- Sub-millisecond gateway overhead per hop
- Zero-allocation hot path in core router
- Connection pooling to all upstream services
- Goroutine worker pools for high I/O throughput
- Stateless design — horizontally scalable by default
- Redis Cluster-ready distributed rate limiter
- Health-check-aware load balancer routing
- Dynamic upstream registration without restart
- Multi-stage Docker build with alpine runtime
- Prometheus metrics + Grafana dashboards included
- OpenTelemetry collector sidecar pattern
- docker-compose for full local observability stack
Tools I reach for.
Languages
- TypeScript
- JavaScript
- Python
- Go
- SQL
Frontend
- React
- Next.js
- Tailwind
- Framer Motion
- Vite
Backend
- Node.js
- Express
- Fastify
- NestJS
- GraphQL
- tRPC
- REST
- FastAPI
The road so far.
Full Stack Developer
- Build and ship features across the full stack using React, Next.js, and TailwindCSS.
- Refactored core React modules for scalability, performance, and security.
- Owns the full release cycle — unit & e2e testing through production deployment.
Full Stack Developer
- Designed and maintained RESTful APIs and gRPC services, replacing REST for optimized data exchange between microservices.
- Built high-performance FastAPI services with automatic OpenAPI docs, leveraging Pydantic for robust data validation.
- Managed MongoDB and MySQL databases; wrote unit tests for both frontend and backend.
- Improved scalability and response times via gRPC bidirectional streaming for high-throughput data operations.
Full Stack Developer
- Developed a music streaming UI — persistent player across all routes, infinite scroll, and album management.
- Implemented social sharing and URL-copy features, and drove new feature proposals end-to-end.
Full Stack Developer
- Translated Figma designs into pixel-perfect React components with Tailwind and Styled Components.
- Handled bug triage, unit & e2e testing, and AWS deployments across multiple client projects.
Got a thing to build?
I'm currently taking on new work for Q3 onwards — full-time roles, contracts, and the occasional weekend collab. The fastest way to reach me is email, but I lurk on the usual places too.