The Art of Building Products That Matter

There's a moment in every product's life when a decision is made. Not the big decisions — those get debated endlessly in meetings and strategy docs. I'm talking about the small ones. The ones nobody will notice.

The animation timing on a button. The error message when something goes wrong. The way a loading state feels.

These decisions reveal everything about the people who built it.

The Metric Trap

Most products today are built backwards. Teams start with metrics — conversion rates, DAUs, retention curves — and work backwards to features. The result is predictable: products that are optimized but not loved.

I've seen this pattern repeatedly across the startups I've built and worked with. At Creditbook, we could have built a basic ledger app and optimized for downloads. Instead, we obsessed over how a small shopkeeper in Lahore would feel using it for the first time. That obsession is what got us to 4 million downloads — not growth hacks, but genuine care for the user's experience.

The best products aren't built by people who are good at optimizing. They're built by people who are good at caring.

Here's what the metric-first approach gets wrong:

The difference isn't about speed. It's about intention.

What Game Development Taught Me

My journey into tech started at twelve years old with a Google search: "How to make games." That search changed everything.

Game development is unique because it forces you to think about experience first. A game that's technically impressive but not fun is a failure. A game with simple graphics but incredible gameplay is a masterpiece. This taught me something that carries into every product I build:

Technology should have personality. It should be useful, yes — but also delightful.

When we built Area of Darkness: No Escape — Pakistan's first AAA VR game — every design choice was driven by a single question: "How does this make the player feel?" Not "what does this optimize for?" but "what does this feel like?"

The Gamification Principle

The most valuable lesson from game development wasn't technical. It was gamification — the art of making experiences not just functional, but genuinely engaging. Consider how the best games teach you:

1. Progressive disclosure — don't overwhelm, reveal complexity gradually
2. Immediate feedback — every action should feel like it did something
3. Micro-rewards — small moments of delight compound into loyalty
4. Clear affordances — the user should never wonder "what do I do next?"

These principles apply to every product. That same question drives how I build enterprise software at Trukkr today. A logistics platform doesn't have to feel cold and transactional. It can feel smart, responsive, alive.

Here's a simple example — adding delight to a loading state:

// Instead of a static spinner...
const LoadingState = () => (
  <div className="animate-pulse text-gray-400">
    Loading...
  </div>
);

// Add personality and context:
const LoadingState = () => {
  const messages = [
    "Finding the best routes...",
    "Matching you with carriers...",
    "Almost there...",
  ];
  const [msg, setMsg] = useState(messages[0]);

  useEffect(() => {
    const interval = setInterval(() => {
      setMsg(prev => {
        const idx = messages.indexOf(prev);
        return messages[(idx + 1) % messages.length];
      });
    }, 2000);
    return () => clearInterval(interval);
  }, []);

  return (
    <motion.div
      key={msg}
      initial={{ opacity: 0, y: 5 }}
      animate={{ opacity: 1, y: 0 }}
      className="text-accent"
    >
      {msg}
    </motion.div>
  );
};

Small things. But they add up.

Mohsin: Excellence as a Discipline

There's a concept that guides everything I build. Mohsin — from the Arabic root Ihsan (إحسان), meaning to do something with excellence and beauty.

Mohsin isn't about perfection. Perfection is a trap — it paralyzes you. Mohsin is about caring enough to make it right. Every detail considered. Every decision intentional. You do it because the work deserves that much.

You do it for the beauty of doing it.

In practical terms, Mohsin means:

• Never shipping something you're not proud of — even if the deadline allows it
• Sweating the details that users feel but can't articulate
• Building with intention — every feature, every interaction, every word has a reason
• Respecting the craft — code quality, design consistency, architectural integrity

What Mohsin Looks Like in Code

It's the difference between:

# This works
def get_users(db):
    return db.query("SELECT * FROM users")

And this:

# This works AND communicates intent
def get_active_users(
    db: Database,
    since: datetime | None = None,
    limit: int = 100,
) -> list[User]:
    """
    Retrieve active users, optionally filtered by last activity date.
    
    Returns users sorted by most recently active first.
    Excludes soft-deleted and suspended accounts.
    """
    query = (
        db.query(User)
        .filter(User.is_active == True)
        .filter(User.deleted_at.is_(None))
        .order_by(User.last_active_at.desc())
        .limit(limit)
    )
    if since:
        query = query.filter(User.last_active_at >= since)
    
    return query.all()

Both "work." Only one shows Mohsin.

The Intersection

The best work happens at the intersection of three things:

1. Design thinking — understanding what people actually need, not what they say they want
2. Engineering excellence — building systems that scale, endure, and are a joy to maintain
3. Human empathy — remembering that behind every data point is a person with frustrations, hopes, and limited patience

When these three align, you get products that don't just solve problems — they make people feel something. That's what I strive for with every line of code and every design decision.

The Framework

Here's how I approach every product decision:

1. Start with the human — Who is this for? What are they feeling right now? What do they wish they were feeling?
2. Design the experience — What's the simplest path from frustration to relief? Where can we add delight?
3. Build the system — How do we make this fast, reliable, and maintainable at scale?
4. Refine the details — What would make someone smile? What would make them tell a friend?

Building for the Long Game

The startups I've co-founded — Trukkr (logistics, $6.4M raised), Creditbook (fintech, 4M+ downloads), Respired.io (AI, Harvard Innovation Lab) — all share a common thread. They weren't built to flip. They were built to matter.

That's the difference Mohsin makes. When you build with excellence as a discipline, the product becomes more than a tool. It becomes something people trust. Something people recommend. Something that lasts.

The market rewards speed. But history remembers craft.

"Let the beauty we love be what we do." — Rumi