← back to the notebook

Projects

each project, a page of the notebook

My Zone01 Dakar journey, sorted into big themes. The common thread: a single microservices application — Inventory API, Billing API, API Gateway, RabbitMQ and PostgreSQL — redeployed at every level of infrastructure abstraction, from network cabling to a CI/CD pipeline on AWS, automating every layer.

the common thread, from bare metal to the cloud

  1. 01NetworkDeep in Net
  2. 02Linux serverDeep in System
  3. 03VMsCRUD Master
  4. 04ContainersPlay with Containers
  5. 05KubernetesOrchestrator
  6. 06AWS cloudCloud Design
  7. 07CI/CDCode Keeper

DevOps & Cloud

The same microservices application, carried from layer to layer: VMs, containers, Kubernetes, AWS, then a full CI/CD pipeline.

  1. Sept. — Oct. 2024

    Pair project

    step 3 of 7 of the common thread

    CRUD Master

    A Python microservices streaming platform, deployed on 3 VMs provisioned automatically with Vagrant.

    First implementation of the common-thread application: Inventory API (movie CRUD), Billing API (orders, message-queue consumer) and API Gateway (single entry point). Each service runs on its own VM, and a single vagrant up rebuilds the whole infrastructure.

    What I did
    • —The 3 services in Python/Flask + SQLAlchemy, configured through environment variables
    • —Full REST CRUD API on /api/movies: search by title, single-item and bulk operations
    • —Asynchronous Gateway → Billing messaging over RabbitMQ, so orders survive a billing outage
    • —Vagrantfile orchestrating 3 Ubuntu VMs on a bridged network with fixed IPs and port forwarding
    • —Idempotent shell provisioning: PostgreSQL databases and grants, RabbitMQ users and permissions
    • —Processes supervised by PM2, endpoints validated with a versioned Postman collection

    Stack — Python 3, Flask, SQLAlchemy, PostgreSQL, RabbitMQ, Vagrant, VirtualBox, Bash, PM2, Postman

    Code

  2. Sept. — Oct. 2024

    Pair project

    step 4 of 7 of the common thread

    Play with Containers

    Migrating the 3-VM architecture to 6 Docker containers orchestrated with Docker Compose.

    The same application, with containers replacing the virtual machines: 6 services (2 PostgreSQL databases, 2 apps, RabbitMQ, API Gateway) with custom images, a private network, persistent volumes, healthchecks and restart policies. From a multi-minute deployment to a single docker compose up.

    What I did
    • —One Dockerfile per service on slim images (python:3.12-alpine, python:3.9-slim), with targeted system dependencies
    • —6-service docker-compose on a private bridge network: only the Gateway publishes a port
    • —Named volumes for PostgreSQL and RabbitMQ persistence
    • —Healthchecks (pg_isready, rabbitmq-diagnostics ping) + depends_on: service_healthy for startup order, restart: on-failure everywhere
    • —Configuration and secrets moved to .env files: no credentials baked into images
    • —Auto-generated Swagger/OpenAPI docs via flask-restx, and a versioned architecture diagram

    Stack — Docker, Docker Compose, Docker networks & volumes, healthchecks, PostgreSQL 14, RabbitMQ, Flask, flask-restx (Swagger), Vagrant, Bash

    Code

  3. December 2024

    Pair project

    step 5 of 7 of the common thread

    Orchestrator

    The microservices architecture orchestrated on a multi-node K3s cluster, with autoscaling, persistence and monitoring.

    From Docker Compose to Kubernetes: a K3s master + agent cluster provisioned by Vagrant, then the whole application deployed as manifests — Deployments, StatefulSets, Services, Ingress, Secrets, persistent volumes and horizontal autoscaling. All driven by a home-made CLI script.

    What I did
    • —2-node K3s cluster via Vagrant: automated install, shared join token, kubeconfig exported to the host
    • —orchestrator.sh CLI (create / start / stop / clean) wrapping the whole cluster lifecycle
    • —4 StatefulSets for PostgreSQL and RabbitMQ, stateless Deployments, Services, Ingress — applied with Kustomize in a dedicated namespace
    • —HPA on the Gateway and apps (1 to 3 replicas at 60% CPU), plus "wait-for" initContainers for startup order
    • —Credentials stored as Kubernetes Secrets injected via secretKeyRef, PV/PVC for stateful components
    • —Observability: Kubernetes Dashboard (dedicated ServiceAccount), Prometheus + Grafana via Helm, centralized logs with Loki

    Stack — Kubernetes, K3s, kubectl, Kustomize, StatefulSets, HPA, Ingress, Secrets, PV/PVC, Helm, Prometheus, Grafana, Loki, Docker Hub, Vagrant, Bash

    Code

  4. Jan. — Feb. 2025

    Solo

    step 6 of 7 of the common thread

    Cloud Design

    The application's entire infrastructure moved to AWS (EKS, RDS, SQS, Lambda), described 100% in Terraform.

    A switch to managed services and Infrastructure as Code: multi-AZ VPC, EKS cluster, private RDS PostgreSQL databases, SQS in place of RabbitMQ, Lambda for billing, Cognito, KMS and CloudWatch — around forty AWS resources provisioned with terraform apply.

    What I did
    • —Networking in Terraform: VPC, public and private subnets across AZs, Internet Gateway, NAT Gateway — databases never publicly exposed
    • —EKS cluster with a managed node group, control-plane and worker IAM roles, and a dedicated cluster-autoscaler policy
    • —2 RDS PostgreSQL instances in private subnets, custom parameter group and Enhanced Monitoring
    • —RabbitMQ replaced by SQS, billing as a VPC-attached Lambda (Python) with a least-privilege IAM role
    • —Security and observability: Cognito, KMS encryption, VPC Flow Logs, a CloudWatch CPU alarm wired to SNS
    • —Cluster audit script combining Trivy and kube-bench (CIS Benchmark for EKS)

    Stack — AWS VPC, EKS, RDS, SQS, Lambda, IAM, Cognito, KMS, CloudWatch, SNS, Terraform, Kubernetes, Trivy, kube-bench, Python

    Code

  5. May 2025

    Solo, with occasional help

    step 7 of 7 of the common thread

    Code Keeper

    A complete self-hosted CI/CD chain: from provisioning the infrastructure to production, with security scans and manual approval.

    The culmination of the track: a GitLab instance and its runners deployed on AWS with Ansible, a Terraform + Terragrunt infrastructure pipeline across two environments with encrypted remote state on S3, and one application pipeline per microservice — build, test, scan, image, staging, approval, production.

    What I did
    • —GitLab infrastructure provisioned with Terraform; instance and runners (shell and docker) installed and registered by Ansible playbooks
    • —6-stage infrastructure pipeline: init → validate → plan → apply-staging → approve → apply-production
    • —Multi-environment Terragrunt (staging / production) with an encrypted S3 backend and one state key per environment
    • —Per-microservice pipeline: build, unit tests, Snyk scan, Docker image tagged by commit SHA pushed to the GitLab registry
    • —Automatic deployment to staging, mandatory manual approval gate before production
    • —No hard-coded secrets (protected variables, SSH keys injected at runtime), protected branches, tfsec, a shared reusable YAML template

    Stack — GitLab CI/CD, GitLab Runners, Ansible, Terraform, Terragrunt, AWS (EC2, S3, EKS, RDS), Docker-in-Docker, Snyk, tfsec, Infracost, Kubernetes, YAML

    Code

Systems

  1. September 2024

    Solo

    step 2 of 7 of the common thread

    Deep in System

    Installing, hardening and automating a production Ubuntu server from scratch.

    Full administration of an Ubuntu Server LTS: manual partitioning, static networking, SSH and firewall hardening, fine-grained user management, services (FTP, MySQL, WordPress) and automated backups. Delivered as a reproducible OVA image, then fully rewritten as an Ansible playbook for an idempotent, replayable setup.

    What I did
    • —Manual partitioning with fdisk (/ 15G, /home 5G, /backup 6G, swap 4G) and static networking via Netplan
    • —Hardening: SSH root login disabled, SSH on port 2222, UFW with explicit rules, sudo access by SSH key only
    • —Read-only chrooted FTP (vsftpd) on /backup, secured MySQL and WordPress behind Apache
    • —TLS on Apache and vsftpd with an OpenSSL certificate (HIGH ciphers, SSLv2/v3 disabled, FTP forced over SSL)
    • —Backups: bash dump script + timestamped tar.gz archive, scheduled daily in cron with logging
    • —Bonus: the whole setup rewritten as a 6-role Ansible playbook (system, network, security, users, services, backup) with Ansible Vault

    Stack — Ubuntu Server LTS, Bash, Netplan, SSH hardening, UFW, vsftpd, MySQL, WordPress, Apache2, OpenSSL/TLS, cron, Ansible, VirtualBox

    Code

Networking

  1. August 2024

    Solo

    step 1 of 7 of the common thread

    Deep in Net

    Designing a complete multi-site network in Cisco Packet Tracer, starting from a single IP address.

    First project of the DevOps track: 8 progressive network-design exercises, from cabling two PCs to a dynamically routed multi-subnet architecture with application-level network services. The whole addressing plan was derived by hand from one given IP.

    What I did
    • —Full addressing plan through subnetting (masks, splitting, reserved infrastructure IPs) from a single IP
    • —Configured routers and switches, routing tables and default gateways; compared hub vs switch against the OSI model
    • —Hybrid addressing: static IPs for servers and critical equipment, DHCP for client machines
    • —Network services: DHCP, DNS, HTTP/HTTPS
    • —Dynamic routing with RIP, then a bonus migration to OSPF
    • —Extra bonuses on my own initiative: an SMTP server (mailing a recipient list) and an NTP server

    Stack — Cisco Packet Tracer, TCP/IP, Subnetting/VLSM, RIP, OSPF, DHCP, DNS, HTTP/HTTPS, SMTP, NTP, OSI

    Code

Go

Web applications in plain Go, no framework: from a TCP chat server to a forum with authentication and SQLite, up to a real-time WebSocket version with private messaging.

  1. April — July 2023

    Solo

    Ascii-Art

    Turning text into ASCII art from custom fonts, with file export and a web interface.

    A small Go tool that converts a string into ASCII art using character banks loaded from text files, with two extensions: saving the output to a file (-fs) and a web interface to type text and export the result (-web-export-file).

    What I did
    • —Parsing ASCII font files and converting character by character, line by line
    • —CLI arguments to pick the font and the input text
    • —FS bonus: writing the result to an output file
    • —Web bonus: a Go HTTP server serving a page to type text live and download the rendering

    Stack — Go, net/http, HTML, CLI

    Code

  2. June — July 2023

    Solo

    Net-Cat

    A multi-client chat server over raw TCP, nc-style, with history and message broadcasting.

    A reimplementation of NetCat's group-chat behaviour: a TCP server accepts several simultaneous connections, gives each client a nickname, broadcasts messages to everyone connected and logs the session.

    What I did
    • —TCP server with concurrent connections (goroutines) and a port passed as a CLI argument
    • —Nickname assignment and broadcasting to every connected client except the sender
    • —Message history for newcomers and server-side logging (log.txt)
    • —Build script and a custom welcome message

    Stack — Go, net/TCP, goroutines, CLI

    Code

  3. June — July 2023

    Solo, one team variant

    Groupie Tracker

    Consuming an external artists-and-concerts API and building a search and visualization interface on top of it, in 4 iterations.

    A Go web application that queries a public REST API (artists, locations, dates, relations) and displays the results as cards. Picked up three more times to add search with filters, data visualizations and a team-built variant.

    What I did
    • —Consumed a multi-endpoint JSON API (artists, locations, dates, relations) with server-side parsing in Go
    • —HTML template + CSS interface: artists as cards with image, dates and concert locations
    • —Search bonus: search bar and dynamic filters (name, creation date, location, number of members)
    • —Visualization bonus: charts of concerts, dates and locations
    • —Pair-built variant: branches, merges and a shared feature split

    Stack — Go, net/http, html/template, REST API, CSS, JavaScript

    Code

  4. Aug. — Sept. 2023

    Solo

    Forum

    A complete discussion forum: accounts, categories, likes and dislikes, filters — with image upload as a bonus.

    A forum in plain Go (net/http + html/template) backed by SQLite: sign-up, topics, replies, likes/dislikes and category filters. The bonus version lets users attach an image to a post.

    What I did
    • —SQLite schema and data-access layer (internal/dataBase)
    • —Authentication (sign-up and login) with confirmation and error pages
    • —Topics, replies, likes/dislikes on posts and comments, category filters
    • —Server-side rendering with html/template, no front-end framework
    • —Bonus: multipart upload of an image attached to a post

    Stack — Go, net/http, html/template, SQLite, go-sqlite3

    Code

  5. Dec. 2023 — Jan. 2024

    Pair project

    Real-Time Forum

    The same discussion platform, rethought as a single-page application with real-time private messaging.

    A major evolution of the forum: no more page reloads (a vanilla JavaScript SPA) and real-time private messaging over WebSocket, with an online-users list sorted by latest conversation and history loaded on scroll.

    What I did
    • —Layered backend: one controller per domain (session, user, post, comment, like, message, category)
    • —WebSocket server (gorilla/websocket): targeted private messages and live online / offline presence
    • —100% vanilla JavaScript SPA front end: no-reload navigation, dynamic DOM rendering
    • —Contacts sorted by latest conversation, then alphabetically for new users
    • —Messages loaded 10 at a time on scroll, with throttle/debounce
    • —User sessions and SQLite persistence, carrying over the previous forum's features

    Stack — Go, net/http, gorilla/websocket, SQLite, JavaScript (SPA), throttle/debounce

    Code

JavaScript

  1. October 2023

    Team project

    ClonerNews

    Rebuilding the Hacker News interface with live data and client-side rate limiting.

    A web client consuming the public Hacker News API (Firebase) to show stories, comments, jobs and polls in real time, throttling requests so the API is never flooded.

    What I did
    • —Consumed the Hacker News Firebase API: stories, nested comments, jobs, polls
    • —Live updates through periodic polling, rate-limited to respect API quotas
    • —Vanilla HTML/CSS/JS interface, navigation across content types and nested comment threads

    Stack — JavaScript, HTML / CSS, Hacker News API (Firebase), rate limiting

    Code

  2. Oct. — Nov. 2023

    Team project (3 people)

    Pac-Man

    A playable Pac-Man, running at a steady 60 FPS with no Canvas and no framework — just the DOM.

    The game written entirely in vanilla JavaScript, manipulating the DOM directly, under a strict constraint: 60 frames per second with no dropped frames, responsive keyboard controls, a pause menu and a scoreboard.

    What I did
    • —Game loop on requestAnimationFrame for smooth 60 FPS rendering without Canvas
    • —DOM rendering tuned to minimize reflows and repaints, with continuous performance profiling
    • —Game logic: movement, collisions with walls and ghosts, lives, score and timer
    • —Keyboard controls with no noticeable input lag
    • —Pause menu (continue, restart, quit) without interrupting the animation
    • —Sprites and music for the atmosphere

    Stack — JavaScript, vanilla DOM, requestAnimationFrame, HTML / CSS

    Code

  3. January 2024

    Solo

    GraphQL Profile

    A personal dashboard that queries a GraphQL API and turns the results into hand-built SVG charts.

    A vanilla JavaScript front end that authenticates against a GraphQL API, fetches the user profile (XP, audit ratio, curriculum) and draws its visualizations in native SVG, with no charting library.

    What I did
    • —JWT authentication, with client-side token storage and refresh
    • —GraphQL queries with nested arguments, aggregations (transaction_aggregate) and filters (where)
    • —Hand-built dynamic SVG charts: XP over time, breakdown per project
    • —Front end split into modules by responsibility (login, profile, graphql, app)

    Stack — JavaScript, GraphQL, SVG, JWT, Bootstrap

    Code

Rust

Five projects in Rust, from the most constrained (a shell) to the most visual (a 3D multiplayer shooter): memory management, low-level syscalls, networking and concurrency.

  1. May — June 2024

    Solo

    Smart Road

    Simulating a 4-way intersection in real time and getting a continuous stream of vehicles across without collisions.

    A real-time graphical simulation (SDL2 rendering) of an intersection: vehicles spawned continuously with routes (straight, left, right), priority handling to avoid collisions, and end-of-session statistics.

    What I did
    • —Domain split into modules: vehicles (position, speed, route), lanes and rules, statistics
    • —Rendering and game loop with SDL2: sprites, textures and on-screen text
    • —Random traffic generation with flow control, no collisions at spawn
    • —Collision detection and prevention algorithm around the intersection
    • —End-of-session stats: speeds, min/max crossing times, near-misses avoided

    Stack — Rust, SDL2 (image, ttf), rand

    Code

  2. June 2024

    Solo

    Filler

    Writing the AI of a bot that must conquer as much territory as possible on a grid, against rival bots.

    Each turn, the bot receives the board state and a piece to place, and must pick the placement that grows its territory while blocking the opponent. The provided game engine runs in Docker for bot-versus-bot matches.

    What I did
    • —Decision algorithm in Rust: parsing board and piece from stdin, scoring candidate positions, picking the best placement
    • —Docker test environment to play against the provided bots (bender, terminator)
    • —Build script to compile and run the binary in the engine quickly

    Stack — Rust, Docker, heuristics

    Code

  3. June — July 2024

    Team project (4 people)

    Localhost

    A multi-site HTTP/1.1 web server, with CGI and file uploads — and no HTTP server library at all.

    A low-level HTTP server in Rust built straight on epoll for non-blocking I/O, able to serve several virtual hosts from a JSON configuration, run CGI scripts (PHP), and handle multipart uploads and sessions.

    What I did
    • —Event loop on native epoll: thousands of concurrent connections without a thread per connection
    • —HTTP/1.1 parser and serializer: methods, headers, status codes, body
    • —Multi-site JSON configuration: virtual hosts, multiple ports, error pages, max body size, routes, redirects
    • —CGI support: running PHP scripts based on the extension configured per route
    • —Multipart uploads and user sessions (uuid identifiers)
    • —Load-test scripts for large files and chunked transfers

    Stack — Rust, epoll, HTTP/1.1, CGI, serde, multipart, uuid, PHP (CGI)

    Code

  4. August 2024

    Pair project

    0-Shell

    Reimplementing the essential shell commands without going through /bin/sh.

    A command interpreter in Rust that natively reimplements the most common Unix built-ins, with ls --color-style highlighting of files and folders.

    What I did
    • —Built-ins cat, cd, cp, echo, ls (-l -a -F), mkdir, mv, pwd, rm on direct syscalls, no wrapper around /bin/sh
    • —UID/GID → name resolution through libc for ls -l
    • —Timestamps formatted with chrono, columns aligned with tabular
    • —Colors to tell files, folders and executables apart
    • —Installable with cargo install --path .

    Stack — Rust, libc, chrono, colored, tabular, Cargo

    Code

  5. August 2024

    Team project (7 people)

    Multiplayer FPS

    A networked first-person shooter in a 3D maze, inspired by Maze War.

    A client-server game in Rust: a Tokio server coordinates matches over UDP, and each client renders the maze in 3D with Bevy and Rapier physics. At launch, players pick the server address, a nickname and one of three difficulty levels.

    What I did
    • —UDP client-server architecture: async Tokio server, more than 10 players connected at once
    • —Typed JSON message protocol (connect, actions, shots, health, death, disconnect) broadcast to every player
    • —3D maze in Bevy, with collisions and physics bodies through bevy_rapier3d
    • —Shooting on the space bar, hit detection on other players and health management
    • —Live minimap and a frame-rate counter, the game staying above 50 FPS
    • —3 difficulty levels chosen when starting the server

    Stack — Rust, Bevy, bevy_rapier3d, Tokio, UDP, serde_json

    Code

PHP

  1. April — June 2024

    Solo

    Mister Quiz

    A multi-category quiz application with score tracking and XP progression, built on Laravel.

    Users answer questions sorted by category, earn experience and follow their progress. My first project on a full MVC framework with an ORM.

    What I did
    • —Laravel/Eloquent data model and migrations: users, categories, questions, scores, XP
    • —Quiz logic: questions per category, scoring, XP awards and persisted progress
    • —Environment configuration (.env, MySQL) and migrations through Artisan
    • —Light JS/CSS front end for picking answers with instant visual feedback

    Stack — PHP, Laravel (Eloquent, Artisan, Blade), MySQL, Composer, JavaScript / CSS

    Code

C

  1. May — June 2023

    Solo

    ATM Management System

    A bank account management system in plain C, with secure authentication and file-based persistence.

    A C console application simulating a banking system: account creation, deposits and withdrawals, transfers, history — with masked password entry in the terminal and data stored in structured flat files.

    What I did
    • —Masked password entry through termios attributes (echo off, clean restore even on error)
    • —Persistence in structured files read and written with fscanf/fprintf, typed fields
    • —Operations: create, update, view, deposit/withdraw, transfer between accounts, delete, transfer ownership
    • —Code split into modules (auth.c, system.c, main.c) with a shared header for the User/Record structs
    • —Robust user input: numeric validation, stdin buffer flushing, a complete interactive menu

    Stack — C, termios, file persistence, Makefile

    Code