Skip to content
DV
Projects

Things I've built

Labtools

Personal Project

Inventory & IoT Monitoring for a Neuroscience Lab

Labtools is a custom platform built for the Neural Circuits Laboratory at the University of Valencia. It brings together two everyday needs:

  1. A personal + shared inventory to track consumables and equipment, with low-stock alerts and provider management, and
  2. A lightweight IoT telemetry system (Raspberry Pi Zero 2W) that monitors the animal colony environment (temperature, humidity, light) and notifies researchers on anomalies to support animal welfare.
Login page

Purpose and Overview

The lab needed a single place to:

  • keep accurate stock across teams and individuals,
  • standardize purchases via provider/material mappings, and
  • maintain stable conditions around the animal rooms with automated alerting.

Labtools provides a clean UI for inventory workflows and a reliable data pipeline that ingests sensor readings via MQTT, processes them in a Go backend service, persists them, and triggers alerts when thresholds are exceeded.

Main dashboard: inventory + environment at a glance
Provider view and material mapping

IoT Monitoring - Animal Colony

Small Raspberry Pi Zero 2W devices collect temperature, humidity, and illuminance via onboard sensors. Devices publish readings over MQTT. A Go service consumes, validates, transforms, stores, and checks thresholds; if anything looks off, it alerts researchers to investigate. The application provides a unified dashboard for monitoring all sensor data in real time and historical values.

Pi Zero 2W telemetry node (sensorized)
Charts displaying temperature, humidity, and light levels over time

System Architecture

┌────────────────────────┐      MQTT       ┌──────────────────────────┐
│ Pi Zero 2W + Sensors   │ ──────────────▶ │  Ingest (Go)             │
│  temp | hum | lux      │                 │  - Validate & transform  │
└────────────────────────┘                 │  - Threshold checks      │
                                           │  - Persistence           │
                                           └─────────────┬────────────┘
                                                         │
                                                         ▼
                                               ┌──────────────────┐
                                               │   Database       │
                                               │  (timeseries +   │
                                               │   inventory)     │
                                               └─────────┬────────┘
                                                         │
                                                         ▼
                                         ┌─────────────────────────────────┐
                                         │ Web App (Inventory + Telemetry) │
                                         │ - Inventory CRUD & providers     │
                                         │ - Live charts & alerts           │
                                         └─────────────────────────────────┘
End-to-end flow: device → MQTT → Go service → DB → UI and alerts

Key Features

  • Personal & Shared Inventory: clear separation and easy collaboration
  • Low-Stock Indicators: color-coded badges and at-a-glance dashboards
  • Provider Management: materials mapped to vendors to speed up orders
  • IoT Environment Monitoring: temp/humidity/light telemetry from Pi Zero 2W
  • Automated Alerts: threshold-based checks to protect animal welfare
  • Auditable History: item changes and sensor trends for traceability

Technology Stack

  • Raspberry Pi Zero 2W (sensor nodes)
  • MQTT (telemetry transport)
  • Go backend service (ingest, transform, thresholds, persistence)
  • Database (inventory + time-series telemetry)
  • Web UI for inventory, dashboards, and alert management

Note: This is a lab deployment; repository and infrastructure details are private. Reach out if you'd like a technical deep-dive.

Impact

Labtools reduced stock-outs, standardized provider ordering, and added proactive monitoring of animal-room conditions. It turned scattered spreadsheets and manual checks into a single, reliable system the entire lab can trust.

Docker Image Update Notify

Personal Project

Stay Updated with the Latest Docker Images

Docker Image Update Notify is a lightweight service that watches running containers and alerts you when a newer image is available. It is designed to drop into Coolify and other containerized environments, with an emphasis on efficiency, modularity, and production readiness.

Purpose and Overview

The goal is straightforward: keep container images up to date without manual checks. It scans running containers, queries registries (DockerHub or private), and notifies you via Email or Telegram when updates are available.

That helps teams react quickly to releases, patches, and security fixes without unnecessary downtime.

┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│   Scheduler     │───▶│  Docker Scanner  │───▶│ Registry Client │
└─────────────────┘    └──────────────────┘    └─────────────────┘
                                │                        │
                                ▼                        ▼
┌─────────────────┐    ┌──────────────────┐    ┌─────────────────┐
│ Notification    │◀───│   Controller     │◀───│  Version Comp.  │
│    System       │    └──────────────────┘    └─────────────────┘
└─────────────────┘
Service architecture at a glance

Key Features

  • Automatic Detection: Scans all running containers automatically
  • Multiple Registries: Supports DockerHub and private registries
  • Smart Filtering: Include/exclude patterns for fine-grained control
  • Notifications: Email (SMTP) + Telegram bot integration
  • Semantic Versioning: Smarter update checks beyond simple tags
  • Scheduling: Cron-like intervals for periodic checks
  • Resource Efficient: Minimal CPU/memory footprint
  • Production Ready: Logging, health checks, and error handling baked in

Inside the System

The service is split into a few focused modules:

Core Modules

  • Docker Scanner: Detects running containers and extracts image info
  • Registry Client: Communicates with DockerHub and registries
  • Version Comparator: Intelligent semantic version comparison
  • Notification System: Sends alerts through email and/or Telegram
  • Scheduler: Manages periodic checks and execution
Notifications in action

Technology Stack

  • Go 1.24+ (service implementation)
  • Docker & Docker API (container scanning)
  • Coolify / Kubernetes / Swarm (deployment ready)
  • SMTP + Telegram Bot API (notifications)
  • Logrus (structured logging)
  • robfig/cron (scheduling)

Architecture at a Glance

  • scanner/ — Docker container detection
  • registry/ — registry API clients
  • version/ — semantic version comparison
  • notify/ — email and Telegram channels
  • scheduler/ — cron-based task manager
  • cmd/main.go — service entrypoint

Getting Started

Prerequisites

  • Docker Engine
  • Go 1.24+ (for local builds)

Install and Run

# Clone
git clone git@github.com:ponytojas/DIUN.git
cd docker-notify

# Run locally
make run-local-once

# Build local version
make build-local

# Run with Docker Compose
cp configs/config.yaml configs/config.local.yaml
docker-compose up -d

For more details on configuration and deployment options visit the repository

Flappy-Ball RL

Personal Project

A Reinforcement Learning Demo

Flappy-Ball RL is a reinforcement learning demo where hundreds of neural-network agents learn a Flappy Bird-style game through evolutionary algorithms. It started as a curiosity about how simple networks can discover control policies, and grew into a playground to compare optimization strategies, visualize learning in real time, and benchmark design choices.

Purpose and Overview

The project showcases population-based learning with genetic algorithms and alternatives (ES, DE, PSO). Agents read a compact game state and decide when to jump. Fitness is based on survival and pipe passing, with shaping terms that encourage smooth flight and robustness.

Training viewport with live stats

Key Features

  • Population Training: 50-500 agents evolve in parallel
  • Real-time Visualization: See improvement across generations
  • Interactive Controls: Tune physics, NN, and evolution at runtime
  • Live Analytics: Fitness trends, generation stats, best agent playback
  • Persistence: Save and load top genomes
  • Deterministic Mode: Seeded RNG for reproducible runs

What's Inside the AI

Neural Network

  • Inputs: position/velocity, next gap info, distance to ceiling/ground (6-8 features)
  • Hidden layers: 8 → 4 with tanh
  • Output: sigmoid → jump probability

Learning Algorithms

  • Genetic Algorithm (default): tournament selection, uniform crossover (~70%), adaptive mutation, elite preservation, wider weight bounds [-5, 5]
  • Evolution Strategy (μ+λ): self-adaptive mutation for fine-tuning
  • Differential Evolution: diversity-aware exploration for continuous params
  • Particle Swarm: quick convergence via velocity + global/personal bests
Algorithm and physics controls

Game Mechanics

  • Physics: gravity + impulse jump; terminal velocity
  • Pipes: constant gap size, smooth random vertical drift, fixed spacing
  • Fitness: survival distance + gap-centering bonus + pipe-pass reward - movement penalty
  • Determinism: procedural generation seeded for consistency
Live training metrics

Technology Stack

  • React 19 + TypeScript (UI and state)
  • Vite (build and dev)
  • Canvas 2D API (rendering at 60 FPS)
  • Vitest (tests)
  • Zero external ML deps (custom NN, GA/ES/DE/PSO, RNG, math)

Architecture at a Glance

  • game/nn.ts — forward pass and genome ops
  • game/evolve.ts — genetic algorithm core
  • game/world.ts — physics, collisions, procedural pipes
  • game/sim.ts — training loop, generation orchestration
  • game/render.ts — canvas rendering and culling

Getting Started

Prerequisites

  • Node.js 18+
  • pnpm (recommended) or npm

Install and Run

git clone git@github.com:ponytojas/Flappy-Ball-RL.git
cd flappy-ball-rl
pnpm install
pnpm dev      # open http://localhost:5173
pnpm test     # run unit tests
pnpm build    # production build

Live Demo

You can play around with it here.

MyTasks

Personal Project

A Personal Task Logging and Summarization Tool

MyTasks started as a way to better track and summarize weekly work. While my team uses Jira for tasks and tickets, a lot of my work happens outside of it - things like reviewing pull requests, helping teammates, or handling production hotfixes and database interventions.

Every Friday my manager asked for a quick summary of the week and my plan for the next. I often realized I could not remember half of what I had done. That is what pushed me to build a lightweight tool to capture those tasks as they happen.

Purpose and Overview

MyTasks is a simple, focused app for logging daily tasks and generating automated summaries.

Login screen

The interface is split into two parts:

  • A calendar on the left to select the week
  • A daily task list on the right showing the days of the selected week
Main screen

For each day, I can quickly add tasks with the following details:

  • Title
  • Notes or description
  • Status (e.g., done, in progress, blocked)
  • Type (work or personal)
Add task form

This structure keeps a clear record of daily work, even when it does not show up in official tracking systems.

AI-Powered Summarization

One of the most useful features is AI summary generation. I added two buttons:

  • Daily summary
  • Weekly summary

Both call the ChatGPT API to generate natural-language summaries of the tasks recorded, which saves time when sending reports or reflecting on the week.

Summary example

Technology Stack

The app is intentionally minimalistic and optimized for speed. It was built with:

While simple in scope, MyTasks solved a recurring issue in my day-to-day work.

From Personal to Team-Wide

I originally built the app for myself, then shared it with my manager. He liked the idea, and now we are working together to evolve MyTasks into a tool for company-wide usage. It is a clear example of how a personal pain point can turn into broader value.

Test it out

You can try out the app yourself here. There's a demo account to let you explore the features without needing to create an account.