// next entry
More projects are being written up. This section is built to grow — each new one gets its own card here.
available for select work
Prompt Software Engineer
I don't patch symptoms. I trace a problem to where it actually lives, then build the fix that doesn't need fixing again.
// an abstract render of how a request moves through CV Spark's own architecture — content model, template model, and customization overrides resolving into one output
// contact
// about
I overthink things. Not as a flaw I'm managing — as a method. Give me a hard problem and I won't let go of it until I understand exactly why it's happening, not just what makes it stop happening. That difference matters to me more than almost anything else in how I work.
Most of my time goes into the part nobody sees: reading the system until I understand it, running the same failure ten different ways until the pattern shows itself, throwing out the fix that only treats the symptom. I like that work. Debugging isn't a chore I tolerate on the way to building — it's where I do my clearest thinking.
I use logic and structure to get there. I test, I break things on purpose, I iterate until the solution is the simplest one that's actually correct — not the first one that happens to work. When something is difficult, that's usually the signal I'm close to the part worth solving.
I'd rather build one thing I fully understand than ship ten things I'm guessing about.
// how I think
Six frames. Expand any of them — this is the actual order a hard problem moves through in my head, and it rarely runs in a straight line.
Before I touch anything, I break the problem apart. What is actually being asked, versus what's being assumed? Most bad solutions start from a problem statement nobody questioned.
I map the system as it actually behaves, not as it's documented to behave. I'm looking for the real cause — the thing upstream of the symptom everyone's pointing at.
I design toward the simplest structure that resolves the actual cause — not the fastest patch that makes the symptom go away for now.
This is where I do my best work. I go looking for what everyone else missed — the edge case, the silent assumption, the place where the model of the system and the system itself disagree.
I turn the solution into working software — structured so the next person reading it (often future me) can follow the reasoning, not just the syntax.
Working isn't the finish line. I go back over what I built looking for the version that's simpler, faster, or harder to misuse — and I keep iterating until I can't find one.
Think deeply. Build intelligently. Solve relentlessly.
// the bug is rarely where the error shows up
// understand the system before you touch the code
// a problem has a shape before it has a solution
// simple is a decision, not an accident
// featured project
A Flutter app that builds a complete résumé on your phone — fill in your information once, then apply any of fifty distinct visual identities to it and export a finished PDF. Built solo, from the data model up.
Building a résumé usually means fighting someone else's Word template, or handing your data to a web tool that locks you into one layout. On a phone, that gets worse — most builders reduce you to a single generic design because supporting real variety is hard. I wanted neither: your content, and real design freedom, on the device already in your hand.
The hard part was never "make it look nice." It was: how do you support fifty genuinely different visual identities — different layouts, sidebars, skill-bar styles, photo shapes, fonts — without writing fifty near-duplicate screens that all drift out of sync the moment one of them needs a fix?
I modeled a template as pure data, completely separate from the person's content. A CVTemplate is a description — colors, heading and body fonts, a layout enum, a skill-visualization style, a photo-frame shape, a pattern — with nothing about any individual's résumé inside it. The person's data lives in its own CVModel. Any template can render any person's content, because neither one knows the other exists.
Three problems fell out of that decision, and each needed its own answer:
null, meaning "respect the template." A sentinel-object pattern in copyWith lets the app tell "the user didn't touch this" apart from "the user explicitly cleared it," and a set of small resolver methods (resolveFont, resolveHeaderColor…) decide, field by field, whether the template or the user wins.Underneath all of it, each résumé is saved into its own local storage "slot" with a lightweight index, so switching between several drafts doesn't mean re-parsing every saved résumé just to show a list — and any résumé saved under the app's older single-slot format migrates into the new structure automatically the first time it loads, without losing content.
One data model, fifty independent visual identities, and zero per-template content duplication. Add a fifty-first template and it's a new data description — no new form, no new save logic, no touching the other forty-nine.
// a simplified, honest recreation of the template engine above — not a screenshot, five of the app's actual color and type pairings, switchable
Jordan Reyes
Product Designer
Skills
// next entry
More projects are being written up. This section is built to grow — each new one gets its own card here.
// skills
Grounded in what I've shipped, not a wall of logos.
// contact
Let's solve it.