Mohamed Aziz BEN REJEB

Two front-ends, a back office and a client extranet, share the same platform.

An ERP has to answer its users quickly, while part of the work is slow: generating PDFs, sending e-mails, reading documents. That work must not block the API.

• Long-running work goes through RabbitMQ: the API publishes a task, a workflow orchestrator hands it to the workers.
• Schemas, DTOs and contracts live in shared libraries in the monorepo (Turborepo), used by every service.
• Data lives in MongoDB (Mongoose, migrations), with Redis and a file storage.
• Jest tests, Docker containers, GitLab CI.
• AI-assisted engineering: Claude Code agents, automated review and specification.

• The microservices were consolidated into a monorepo, for two reasons: version management and simpler rollbacks.
• Fine-grained microservices, split into several components.
• No Kubernetes for now: it would be over-engineering until the need exists. The stack is already ready for it, so moving to Kubernetes will be simple when the time comes.
• The infrastructure, first provisioned on AWS with Terraform, was migrated to dedicated servers because of cost.
• A simple data migration system.

• Authentication is handled by Keycloak, which the gateway relies on.
• A failed task is isolated in a dead-letter queue.
• The monorepo keeps rollbacks simple.

• I co-designed the initial microservices architecture (API, authentication, orchestrator, mailer, PDF and notification services), then co-led its consolidation into a monorepo.
• I own the platform foundations and take the hardest features end to end.
• I make the architecture decisions, and I scope requests with the Product Owners: feasibility, sizing, specification.
• I arbitrate production urgencies against the roadmap, and I coordinate external contractors: scoping, code review, delivery quality.
• I am the top contributor to the codebase: 58% of non-merge commits (1,266 of 2,174, November 2026).

I ship the MVP first, and I don't try to cover 100% of business cases.

Give pentesters and CISOs a ready-to-use penetration test: an appliance you plug in, driven from a web interface, with attack engines that can also run remotely, on other machines. Each of those engines has to be authenticated individually.

• The architecture is close to the ERP's, but the workers are agents, which can run remotely on other machines.
• The agents communicate over MQTT.
• Redis handles caching and session management for the attack engines; data lives in MongoDB and PostgreSQL.

• The whole system is managed with certificates: each agent has its own certificate.
• Security best practices are applied in the code: prepared statements, data encoding, input validation, access control, logging.

• I designed the whole system: the infrastructure, whose rollout I led, and the workflows.
• I built the application core in Flask, front end and back end, and the attack engines.
• I built the back office for managing clients and licences.
• I set up the production, test and development environments, with GitLab CI/CD and Harbor on bare-metal servers.
• I supervised the outsourced migration to a new version: specifications, acceptance testing and delivery quality follow-up.
• I coordinated the team: splitting work, assigning tasks, code review.

Computing a reputation with AI means collecting data with crawlers, then analysing it: work spread across several workers, which has to be coordinated and tracked.

• An agent-style architecture as early as 2020, in the form of the time: an orchestrator hands each worker its tasks, through RabbitMQ.
• Authentication relies on Keycloak, as the OpenID provider, configured with the Kong API gateway.
• The API adds a layer on top of Express, organised following clean architecture.
• Crawler statistics have their own microservice.
• Data lives in MongoDB and PostgreSQL; monitoring runs on Grafana and Prometheus.

• I wrote the Software Requirements Specification (SRS) and designed the solution in UML: functional analysis, technical architecture, components to build.
• I designed and implemented the overall architecture: microservices, message broker, workers and workflows.
• I built the API, a layer on top of Express (Node.js) following clean architecture, and a Python library for connecting to RabbitMQ and managing queues.
• I built the orchestrator that hands each worker its tasks, and a microservice that tracks, computes and stores crawler statistics.
• I laid the foundations of the React interface: Keycloak authentication, menu, pages, routes, main forms and workflows.
• I set up the Kubernetes cluster on bare-metal servers, the Harbor registry for Docker images and the manifests for each release.

The backend that distributes and collects connected-vehicle data is spread across several clusters and servers.

Monitoring it called for a monitoring interface, an API to feed it, and authenticated exchanges between servers.

• The whole API is built as GraphQL microservices, with Apollo on Express and Node.js.
• The microservices are spread across several Kubernetes clusters.
• The reverse-engineered part was rewritten in Go.
• Data lives in MongoDB; infrastructure is handled with Terraform and Ansible.

• Servers authenticate with each other over ZeroMQ.
• The Kubernetes clusters are secured following best practices.

• I brought the front end used to monitor the backend: that is the "GUI" in the name.
• I did the overall design of the application, and implemented the microservices architecture, defining where each component runs across the clusters and servers.
• I built the entire API as GraphQL microservices (Apollo, Express, Node.js), and the React foundations: menu, data tables, main pages.
• I built the server-to-server authentication over ZeroMQ, and applied security best practices to the Kubernetes clusters.
• I reverse-engineered part of the application and rewrote it in Go.
• Code review, refactoring and bug fixing; team coordination, splitting work and assigning tasks.