Pickwise

Overview

The Product

Pickwise helps users compare options using a weighted decision framework. Users can add the choices they are deciding between, define what criteria matter most, assign weights to those criteria, and score each option from 0–10. The app then calculates a ranked result and provides a breakdown of why the top choice leads.

I built this project to explore the overlap between product thinking and engineering. I wanted to create something that felt intuitive from a user standpoint, but also grounded in clear logic and explainability.

Problem

Goal

• Create a decision workflow that turns ambiguity into a clear step-by-step process.
• Make rankings feel transparent by exposing how each criterion contributes to the outcome.
• Persist user progress without requiring an account or backend setup.
• Build a strong foundation for a future LLM reasoning layer that augments the experience.

Product Thinking

Why Pickwise

I wanted to build something that bridged product strategy and engineering. Many tools either lean too heavily on intuition or too heavily on black-box automation. Pickwise starts with a deterministic scoring system so users can stay in control, understand what matters most, and make decisions with more confidence.

The broader vision is to create a hybrid decision product: one that begins with structured logic and later incorporates AI-assisted reasoning without sacrificing transparency.

Experience Flow

How the Product Works

Architecture

Core Technical Decisions

Code Highlights

Important Snippets from the App

Since Pickwise was something I coded myself, I wanted the case study to show not just the interface, but the technical thinking that shaped the product. These snippets highlight the parts of the app that were most important to resilience, logic, and explainability.

function safeLoadCurrent() {
  const raw = localStorage.getItem(STORAGE_KEY);
  if (!raw) return null;
  const parsed = safeJsonParse(raw);
  if (
    !parsed ||
    !Array.isArray(parsed.criteria) ||
    !Array.isArray(parsed.options) ||
    typeof parsed.scores !== "object"
  ) {
    return null;
  }
  return parsed;
}

useEffect(() => {
  localStorage.setItem(
    STORAGE_KEY,
    JSON.stringify({ criteria, options, scores, optionNotes })
  );
}, [criteria, options, scores, optionNotes]);

useEffect(() => {
  localStorage.setItem(HISTORY_KEY, JSON.stringify(history));
}, [history]);

const breakdownForOption = (optionId) => {
  if (!hasEnoughToRank) return [];
  return criteria.map((c) => {
    const w = Number(c.weight);
    const weightShare = totalWeight > 0 ? w / totalWeight : 0;
    const rawScore = scores[optionId]?.[c.id];
    const scoreNum =
      typeof rawScore === "number" ? rawScore : Number(rawScore) || 0;
    const contribution = scoreNum * weightShare;

    return {
      criterionId: c.id,
      name: normalizeName(c.name) || "(unnamed)",
      weightShare,
      score: scoreNum,
      contribution,
    };
  });
};

const ranked = useMemo(() => {
  return [...options]
    .map((o) => ({ ...o, total: totalForOption(o.id) }))
    .sort((a, b) => (b.total ?? -Infinity) - (a.total ?? -Infinity));
}, [options, criteria, scores, totalWeight]);

lines.push(
  `${winnerName} wins because its biggest strength is ${primary.name} (weighted ${Math.round(
    (primary.weightShare || 0) * 100
  )}%).`
);

if (secondary) {
  lines.push(
    `It also scores well on ${secondary.name}, giving it a strong overall balance.`
  );
}

Product + Engineering

What I Learned While Building It

Live Demo

See the Product in Action

I wanted the case study to end with the product itself, so viewers can move from the strategy and code directly into the experience.

Takeaway

What This Project Shows

1. Good product logic should feel understandable. Users trust systems more when they can see why an outcome happened instead of only receiving a score.
2. Technical implementation shapes product quality. Persistence, validation, and performance decisions all influenced how trustworthy and usable Pickwise felt.
3. AI works best when paired with structure. Pickwise reinforced my interest in products that combine deterministic systems with AI-assisted reasoning in a way that stays human-centered.