Current direction
SaaS platforms, APIs, multimodal tools, workflow automation, and AI-assisted systems built to feel clear and genuinely useful.
Portfolio / Enniskerry, Co. Wicklow
Software that stays clear when things get complicated.
I am a full-stack developer with a support-and-operations background, so I naturally care about reliability, edge cases, and the person using the system when a flow goes sideways.
The work I enjoy most lives in the joins: product and implementation, software and media, the point where a good idea has to survive real inputs, real users, and real handoffs.
- Voice and multimodal tooling
- Cloud-aware document tooling
- Testing, CI, and calm debugging
About
Alan Maizon
Argentine-Italian technologist and singer-songwriter based in Ireland, with a background in IT support, automation, software development, and AI-focused projects. I am interested in building practical, human-centered tools across SaaS, multimodal systems, and product workflows.
Originally from Cordoba, Argentina, I moved to Ireland in 2021 during the COVID period and have kept building across troubleshooting, systems thinking, product design, and software projects that combine clarity, reliability, and useful outcomes.
Background
Customer-facing support, infrastructure environments, automation work, personal software projects, and steady hands-on troubleshooting.
Creative thread
My singer-songwriter work shapes how I think about communication, product feel, and the human experience of using a tool.
Selected Projects
Work that says more than a profile paragraph
The quickest way to understand how I think is through the work. I like products with real flows, explicit boundaries, and enough complexity to make good engineering choices matter.
Featured build
My Voicebank
A reproducible pipeline for training DiffSinger singing voice synthesis models from your own recordings, built around the OpenVPI ecosystem.
Voice tech workflow
GitHub
Problem
Training a voice model from personal recordings usually means stitching together several specialist tools, repeated setup steps, and brittle handoffs between stages.
Approach
I treated it as a workflow problem first. The project maps the path from raw recordings through labeling, forced alignment, note extraction, and training so the process stays repeatable rather than improvised every time.
Architecture
The build is organized around explicit stages and tooling boundaries: dataset prep, alignment, note extraction, model training, and environment-specific execution across Colab, GCE, and local Mac setups.
Stack
DiffSinger, OpenVPI tooling, forced alignment, note extraction, workflow automation, Colab, Google Cloud, and local Mac training paths.
Technical decisions
- Structured the pipeline around named stages so each step can be checked and rerun without guessing.
- Kept labeling, alignment, and note extraction visible instead of hiding them behind a black-box setup.
- Designed the workflow to work across Colab, GCE, and local Mac environments instead of locking it to one machine.
- Treated documentation and repeatability as part of the product, not as cleanup after the technical work.
Outcome
This is the clearest overlap between my technical and creative work. It turns a niche, easily frustrating process into something more understandable, reusable, and practical.
What it shows
I like making complicated toolchains feel more navigable, especially when the work sits between software, media, automation, and real human use.
Cloud and integration case study
Nebula
A drafting workspace for turning dense source material into traceable, reviewable submissions.
Cloud-oriented full-stack system
GitHub
Problem
Document-heavy drafting workflows are slow, difficult to trace, and easy to derail when requirements are missed or evidence is weak.
Approach
I broke the system into explicit stages: upload and parsing, requirement extraction, cited section generation, coverage analysis, unresolved evidence review, and export.
Architecture
The frontend is a Next.js workspace. The backend is a FastAPI pipeline with isolated services for parsing, validation, coverage, and export. Local development uses SQLite and filesystem storage, while the AWS deployment path is designed around RDS, S3, Bedrock, and Cognito-aware routing.
Stack
Next.js, React 19, FastAPI, SQLite, Postgres-ready data paths, S3, Amazon Bedrock, Cognito, Docker, GitHub Actions, and typed frontend utilities for traceability and quality diagnostics.
Technical decisions
- Kept parsing, generation, coverage, and export as separate modules so failures are easier to diagnose and improve.
- Added quality-signal panels and unresolved-gap views so users can see weak inputs before exporting output.
- Built a cloud-ready deployment path with AWS readiness scripts covering ECS, RDS, S3, CloudFront routing, and config checks.
- Protected delivery quality with backend tests, type checks, build verification, and docker smoke steps in CI.
Outcome
Nebula is the clearest example of how I think about structure. Each stage has a job, the interfaces are explicit, and the deployment path was designed to feel real instead of hand-waved.
What it shows
I like breaking broad product problems into services, checks, and review steps that keep the output explainable for the people using it.
Systems-thinking proof of concept
Entropy
A research-heavy prototype for exploring how a system can absorb information, challenge itself, and update its own model over time.
Proof-of-concept system
GitHub
Problem
I wanted to explore continual learning as a software architecture problem, not just as prompt experimentation.
Approach
I designed a system with separate ingestion, memory, reasoning, orchestration, and API layers so each concern could be tested and evolved independently.
Architecture
FastAPI exposes ingestion and reasoning endpoints. The backend coordinates vector memory, graph memory, and episodic memory, while a React and Vite frontend acts as a lightweight dashboard over the system.
Stack
FastAPI, React, Vite, Qdrant, Neo4j, SQLite, Pydantic settings, Docker Compose, and pytest.
Technical decisions
- Separated vector, graph, and episodic memory so each one has a clear role in retrieval, structure, and history.
- Kept API endpoints narrow around ingestion, hypothesis generation, reasoning cycles, and graph inspection.
- Used Docker Compose to stand up local supporting infrastructure instead of hiding dependencies behind assumptions.
- Documented the architecture heavily so the proof-of-concept remains understandable as the system grows.
Outcome
It is deliberately experimental, but the implementation still follows rules I care about: clear module boundaries, observable behavior, and documentation good enough that future changes stay possible.
What it says about me
I enjoy ambitious ideas, but I only trust them when the system underneath is readable and testable. This project let me prove that instinct.
How I Work
Where my working style comes from
Before software became the main thing, I was already learning how to diagnose problems, protect live environments, and make repeatable work easier for the next person.
Troubleshooting under pressure
At Spirit Radio I handled Windows, network, and configuration problems on site. That taught me to narrow unknowns quickly, reproduce failures, and explain the fix clearly while people are waiting on the result.
Working carefully around live systems
At AWS I worked around live server infrastructure and structured change procedures. That reinforced habits I now bring into software: move carefully, verify assumptions, respect dependencies, and escalate cleanly when a boundary matters.
Documentation that actually helps
At Sacred Space I wrote Bash scripts for audio processing tasks and standardized recurring steps. I like leaving systems with clearer runbooks, less repetition, and fewer avoidable handoff problems.
Customer-facing and operations roles mattered more than they might look on paper. They taught me to stay calm, be useful, and keep the human side of the system in view.
Toolbox
Tools I reach for often
Languages
Python, JavaScript, SQL, Bash
Frontend
React, Next.js, Vite, semantic HTML, responsive CSS, accessibility-minded UI work
Backend
Django, Django REST Framework, FastAPI, REST APIs, authentication flows, webhooks, validation
Data
SQL-backed workflows, relational modelling, SQLite, Postgres-ready application paths, export pipelines
Cloud / Dev Tools
AWS, Docker, Git, GitHub Actions, CI concepts, Redis, Linux, macOS, and structured debugging
Contact
If the work feels like a fit, say hello!
I am looking for a junior or early-career full-stack role where careful implementation, curiosity, and good communication are useful from day one.
Email is the simplest way to start. If you want the formal version too, the CV is available as supporting context rather than the main story.
- Based in Enniskerry, Co. Wicklow, Ireland
- Interested in product, platform, and workflow-heavy web software
- Comfortable working across engineering, product, and operational context
Useful links
Enough context for a quick first pass
Start with email. GitHub and LinkedIn fill in the rest.
Email
maizonalan@gmail.com
Best route for recruiter outreach and role discussions.
GitHub
github.com/alanmaizon
Source code and project implementation detail.
LinkedIn
linkedin.com/in/maizonalan
Professional profile and role context.
Location
Enniskerry, Co. Wicklow
Ireland based, open to conversations about fit and team context.
If you prefer the one-page version, the CV is here.