Technical Knowledge

Angular

Built my own website using Angular, and later came back to it for a fun chessboard game experiment using SSR with incremental hydration. Angular may be verbose, but it's powerful when you need structure.

Vue.js & Nuxt

Created several personal projects using Vue's component-based architecture. Nuxt added a nice SSR layer when needed. I enjoy how Vue keeps things clean and makes progressive enhancement feel natural. Recent projects include building data visualization dashboards with Vue 3's Composition API and leveraging Nuxt 3's hybrid rendering for optimized performance.

React & Next.js

Five years of React experience, with a recent focus on Next.js for its flexible server/client component model. Usually pair it with Node.js APIs, but also comfortable using Next’s built-in API routes and Actions when it makes sense.

Jest and Cypress Testing

I’m a big believer in testing. Used Jest, Cypress, and React Testing Library to keep things solid, with coverage tracked in the CI/CD pipeline. Hitting good coverage (where it counts) is a nice signal things are on track. Having Node.js on both sides made it easy to keep tests flowing end-to-end.

PHP

Two years of PHP experience, it did have a bad name but I am seeing a lot of take up of this in recent years. I have written a React Component for my wife's wordpress recently too.

Express

Used Express extensively as the backend layer for Node.js projects, especially when pairing with React or Next.js frontends. I appreciate how lightweight and unopinionated it is—it lets me shape the architecture without fighting defaults. Built several REST APIs with middleware chains that handle auth, logging, and error hygiene. Recently explored Express with server-side rendering and streaming responses for faster perceived load times.

Spring Boot

Built production-grade REST APIs using Spring Boot, implementing OAuth2 for secure authentication and Redis for caching. I've also developed a gRPC-based service for my home project using Spring Boot Starter, integrating OpenTelemetry to stream telemetry data to Honeycomb. Spotless keeps code quality tight, and I appreciate how Spring Boot balances convention with flexibility. I always make lifecycle and dependency wiring explicit to ensure long-term maintainability

Machine Learning (practical) — PyTorch & TensorFlow notebooks, Docker/requirements for reproducible runs, and containerized inference examples.

• Reproducible: Jupyter notebooks + Docker/requirements + seeded experiments.
• Production-aware: experiment tracking (MLflow / W&B) and containerized serving (TorchServe / TF‑Serving / ONNX).
• Results: trained CNNs & classifiers on Kaggle and local datasets — metrics and inference times available in linked notebooks.

Notebooks & runnable examples: TensorFlow notebooks · PyTorch notebooks. Demo/serving examples are included where available in the repositories.

Started getting to grips with TensorFlow and PyTorch — two frameworks with very different personalities but the same purpose. Working in Jupyter Notebooks inside VS Code made it easy to run code, record notes, and plot results.

Handled platform compatibility (CUDA/ROCm) to enable GPU training on my machine.

Build notes (TensorFlow & CUDA)

Getting TensorFlow running took a bit more effort: I had to build from source to support CUDA 13 and my RX5090 via WSL2 (since it needed sm_10), but the challenge was part of the fun. The build included compiling the runtime with the correct compute capability flags and validating GPU execution in the WSL2 environment.

For both frameworks I built and trained models for linear regression, classification, and CNNs, as well as experimenting with Kaggle datasets and pre-trained models to see how they performed.

PyTorch

I quickly produced examples for linear regression, classification, and simple neural networks. PyTorch felt natural — you can see and control what’s happening, and visualising data and results in Jupyter is effortless. Plotting loss and accuracy with matplotlib made experimentation quick and satisfying.

TensorFlow

TensorFlow came second, but I can see why it’s so popular. It’s straightforward to define and train models — sensible defaults and no explicit loops required. That said, I enjoyed writing those steps out manually in PyTorch; it helped me understand how the training process really works. I haven’t made TensorFlow device-agnostic yet, mainly because it just worked out of the box in my setup.

Reflections

Working with both frameworks side-by-side was ideal — same data, two different approaches. It’s incredibly easy in Python to visualise and compare outputs, and that makes learning rewarding. I’m not an expert yet, but the journey’s underway and I’ll keep investing time into it.

A big shout-out to the excellent CNN Explainer.

Maintain a sophisticated home lab environment running:

• Postfix and Dovecot for email services
• Grafana for monitoring and analytics
• Caddy as a reverse proxy and SSL automation
• MediaWiki for documentation
• RoundCube webmail
• Elasticsearch for search functionality
• MicroK8s for container orchestration