available for select work

Zuber
Amin

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.

Portrait of Zuber Amin
ZA — root cause found

// 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

Have a difficult problem?

Let's solve it

// about

I like problems other people give up on.

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

A trace, not a checklist.

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.

01 think frame

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.

02 analyze frame

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.

03 solve frame

I design toward the simplest structure that resolves the actual cause — not the fastest patch that makes the symptom go away for now.

04 debug frame

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.

05 build frame

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.

06 improve frame

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

CV Spark

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.

Flutter · Dart Provider PDF export Google Fonts shared_preferences
Pproblemwhy it exists

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.

Tthinkingthe actual constraint

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?

Ssolutiondesign as data

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.

Iimplementationwhat that took

Three problems fell out of that decision, and each needed its own answer:

  • Fifty visual identities, one codebase. Layout, skill-style, pattern, and photo-frame are each their own enum. A single skill-visualizer widget reads a template's style enum and switches between real, distinct implementations — a segmented circular arc for one template, a DNA helix for another, a thermometer fill for a third — each its own composition, not a reskinned variant of the others.
  • Letting people customize without breaking the designer's intent. Font size, icon color, header color, and photo-frame shape are all separately overridable — but every override defaults to 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.
  • One job title, two different vocabularies. The career picker offers sixty-eight specific titles ("Chemical Engineer"); the auto-fill summaries are written against fifteen broad categories ("Engineering"). I bridged them with an explicit lookup map for the direct cases, and a fuzzy keyword-matching fallback for anything typed in freehand that doesn't have one.

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.

Rresultwhat it does today

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

Prototyping
Design systems
User research

// next entry

More projects are being written up. This section is built to grow — each new one gets its own card here.

// skills

What that actually took

Grounded in what I've shipped, not a wall of logos.

Languages

  • Dart

Frameworks & libraries

  • Flutter
  • Provider
  • Google Fonts
  • flutter_animate
  • pdf / printing
  • shared_preferences
  • image_picker

Engineering

  • State management architecture
  • Data modeling & local persistence
  • Cross-platform mobile development
  • PDF generation & export

Problem solving

  • Design-system / template architecture
  • Override & inheritance resolution patterns
  • Fuzzy text matching & lookup resolution
  • Root-cause debugging

Prompt engineering

  • Structuring problems for AI-assisted workflows

// contact

Have a difficult problem?

Let's solve it.