We Met at a Boxing Gym and Built a Startup. Here's What Actually Happened.

I met Damien and Vibhav at a boxing gym four years ago.

We weren't looking to start a company. We were just three tech guys who liked hitting things and needed an outlet after staring at screens all day.

But something weird happens when you train with the same people every week. You start talking between rounds. You share ideas. You realize you're all thinking about the same stuff—why your job sucks, what you'd build if you had time, why every startup you've worked at makes the same dumb mistakes.

Eventually those conversations turned into "we should just build something ourselves."

So we did. A lot of somethings, actually.

We Failed at a Lot of Stuff First

Look, I'm not going to pretend we had some genius master plan. We didn't.

We tried everything. Social media marketing agencies, dropshipping, crypto projects, everything. We worked at startups together and watched them make terrible product decisions. We kept thinking "we could do this better."

So we launched OmniSynkAI. Our own startup. Finally.

Most of our previous stuff failed fast. OmniSynkAI actually showed promise. We had users, we had traction, we were building something people seemed to want.

But we kept hitting the same wall, and it was driving me insane.

The Problem That Almost Broke Us

Here's what was happening at OmniSynkAI: We were doing everything "right." Talking to users constantly. Recording every call. Taking detailed notes. Being good product people.

And we were drowning.

After every user interview, I had hours of recordings sitting in Google Drive. Full of gold. Features people wanted. Problems they were facing. Exact words they used to describe their pain points.

But I had no time to actually do anything with it.

I'd tell myself "I'll review this tonight" and then tonight would come and I'd be exhausted and the recording would just sit there. A week later I'd have 10 more recordings. Then 20. Then I'd completely lose track of what anyone said.

The worst part? We'd have product meetings where we'd debate what to build next, and I knew the answer was somewhere in those recordings. Some user had told me exactly what they needed. But I couldn't remember who or when or what they said exactly.

So we'd just... guess. Build based on vibes. Convince ourselves we were being "data-driven" because we had talked to users, even though we weren't actually using any of that data.

It felt like a sick joke. We were doing all this work to listen to users and then completely ignoring them anyway.

I tried everything to fix it. Notion databases. Tagging systems. "Quick debrief" meetings after every call where the three of us would try to remember what was said (these turned into hour-long debates about what users "really meant").

Nothing worked. The problem wasn't note-taking. It was synthesis. It was turning 50 hours of conversations into "here's what we should build and why."

And here's what really bothered me: we weren't special. Every product team I talked to had the same problem. They were all drowning in feedback they couldn't use.

So We Built Aligno

At some point I just snapped. I was sitting there with 47 unreviewed recordings and I told Damien and Vibhav "we're building the thing that solves this."

If we're struggling with this, and every team we talk to is struggling with this, then this is the problem.

But here's the thing nobody tells you about building a product: you're going to be wrong. A lot.

Aligno version 1 was trash. I'm not being humble, it actually sucked. We rebuilt it. Version 2 was better but still missed the mark. We changed direction. Killed features. Rebuilt entire workflows.

Four months in, we're finally at something that actually works the way it should.

The mission became obvious once we lived the pain: help product teams turn user feedback into a roadmap that drives actual decisions.

Not just capture feedback (Otter does that). Not just organize it (Dovetail does that). Actually tell you what to build next based on what users are screaming at you to build.

Here's What We Actually Built

Desktop App That Just Works

I hate tools that make me think. Aligno sits on your desktop and automatically detects when you're in a meeting. It starts recording. You don't do anything.

Why? Because I used to forget to hit record all the time. Or I'd fumble with Zoom settings during the first 5 minutes of a call and miss the most important part.

After the meeting, you can play back the conversation, jump to specific moments, review what was said. It's just there when you need it.

This sounds basic but it's not. Most tools make you remember to do something, configure something, export something. We built it so you literally don't think about it.

AI That Actually Understands Your Product

Here's something that bothered me about every AI tool I used: they're all generic.

You feed them a user interview and they spit out generic summaries. "User wants better performance." Okay cool, what does that mean for MY product specifically?

So when you create a workspace in Aligno, our AI researches your company. It learns what you build, who you sell to, what market you're in, how you position yourself.

This means when a user says something, Aligno doesn't just transcribe it. It understands what that feedback means for YOUR specific product direction.

If a user says "the onboarding is confusing," Aligno knows what your onboarding flow is and can contextualize that feedback properly. It's the difference between taking notes and actually understanding what users are telling you.

One Roadmap That Actually Knows What Users Want

This is the part I'm most excited about.

Every piece of user feedback from every source flows into one place. Customer calls. Support tickets. Sales conversations. User interviews from every person on your team.

Aligno takes all of it and builds a prioritized product roadmap.

Not a static document you update once a quarter. A living roadmap that:

• Synthesizes patterns across every feedback source
• Prioritizes features based on actual user demand and business impact
• Tracks which requests are most urgent and from which customer segments
• Links every roadmap item directly to the user feedback that sparked it

Here's why this matters: most roadmaps are built on gut feel and whoever yells loudest in the room. You say "we should build X" and someone else says "but what about Y" and you debate for an hour and eventually just pick something.

With Aligno, the debate is over. You can literally see that 7 enterprise customers asked for advanced permissions, here's exactly what they said, here's why it's blocking deals, here's the business impact.

No more guessing. No more building based on vibes.

It Works Where You Already Work

I'm so tired of tools that try to replace everything. "Just move your entire workflow to our platform!"

No. You already have tools. Slack for communication. Jira for sprint planning. Google Calendar for deadlines.

Aligno integrates with all of them. Updates in Slack. Tasks flow into Jira automatically. Deadlines stay in your calendar.

But here's the best part: Aligno doesn't just push tasks and disappear. It follows up. Assigns work to the right people. Reminds them about deadlines. And most importantly, attaches the actual user feedback that sparked each feature request.

Why does this matter? Because at OmniSynkAI, I'd create a Jira ticket that said "improve onboarding" and three weeks later an engineer would ask me "why are we building this?" and I'd have to dig through old notes trying to remember which user said what.

Now? Every feature in your backlog has a direct line to the user who requested it. Click a link, you're watching the exact moment in the interview where they described the problem.

No more building in the dark.

What This Actually Looks Like

Let me paint you a picture of what this looks like in practice, because this was literally my life before we built Aligno:

Before: You do 10 user interviews this week. Great! You're talking to users! Gold star for you!

Now you have 10 hours of recordings sitting in Google Drive. You tell yourself you'll review them this weekend. Weekend comes, you're tired, you don't.

Monday rolls around. You have a product meeting. Someone asks "what should we build next?" You panic because you know the answer is in those recordings but you haven't reviewed them.

You spend the meeting trying to remember snippets of conversations. "I think Sarah said something about permissions?" You're basically playing a game of telephone with yourself.

You manually create a few Jira tickets based on what you vaguely remember. You copy some notes into a Google Doc that three people will look at once and never again.

Three weeks later, an engineer asks "who requested this feature?" You spend 30 minutes digging through notes, Slack messages, and half-remembered conversations. You find it eventually. Or you don't and just say "multiple users mentioned it" and hope that's true.

You're working hard. You're doing everything right. But you're still just guessing.

After: You finish your 10 interviews. Aligno has already processed all of them.

You open your dashboard and see: 23 feature requests identified. 15 pain points categorized. 8 action items that need immediate follow-up.

Your roadmap now shows that 7 enterprise customers want advanced permissions. You can see exactly who they are, what they said, why it matters to them, and the business impact of not having it.

Jira tickets are already created with full context. Each one links back to the user feedback that sparked it.

Product meeting happens. Someone asks "what should we build next?" You pull up Aligno and show them that advanced permissions is blocking three deals worth $180K ARR, here's what customers said, here's the pattern we're seeing.

Decision made in 5 minutes instead of an hour-long debate.

Engineer asks "why are we building this?" You send them a link to the exact moment in the customer interview where they explained the problem. Engineer watches 2 minutes of video and completely understands the context.

You ship features users actually want. You spend zero time on manual processing. You spend all your time actually building.

This is what we built Aligno for.

What's Actually Happening (And What I've Learned)

We're four months in and the feedback has been insane.

Teams tell me they're saving 20+ hours a week. That's cool, but honestly that's not what gets me excited.

What gets me excited is when a PM tells me "I finally feel like I actually know what my users want."

Or when someone says "we shipped a feature in two weeks that we'd been debating for three months because we finally had clear evidence of what users needed."

That's the shift. It's not about saving time (though that's nice). It's about confidence.

When you can see all your user feedback in one place, patterns emerge that you couldn't see before. You stop guessing what to build. You stop building whatever the loudest person in the room wants. You stop shipping features that sound cool but nobody uses.

You start building based on what users are literally telling you to build.

Sounds obvious, right? But most teams don't do this. Not because they don't care, but because the tools to do it properly didn't exist.

How We Actually Build This Thing

We're all technical founders. Damien, Vibhav, and I all ship code. We push new features every single week.

And yes, we use Aligno to build Aligno. The irony isn't lost on me. We do user interviews about our user interview tool and then use our tool to synthesize feedback about itself.

Every feature we build comes from real product teams telling us what they need. We're not sitting in a room coming up with clever ideas. We're listening to the 50+ product teams using Aligno and building what they ask for.

It's the same thing we tell other teams to do: listen to your users and actually act on what they tell you.

Where We're Going With This

Look, I'm not going to pretend we're changing the world or whatever. But I do think we're onto something big.

The vision is simple: help every product team in the world ship features users actually want, instead of building useless stuff that seems cool but nobody uses.

Think about how much waste exists in product development right now:

Teams spend months building features that get 2% adoption. Roadmaps are driven by what the CEO thinks is cool instead of what customers are begging for. User feedback gets captured in 17 different tools and never surfaces when actual decisions get made. Product meetings turn into debates about opinions instead of discussions about evidence.

It's insane. And it's not because product teams are bad at their jobs. It's because the infrastructure to do this properly didn't exist.

We're building toward a future where:

• Every product decision is backed by real user evidence, not gut feel
• Roadmaps reflect what customers actually need, not what executives think sounds impressive
• Product teams spend their time building instead of organizing notes
• The gap between "user told us what they want" and "we shipped what they want" shrinks from months to weeks

This isn't just about saving time on admin work (though that's a nice side effect).

This is about fundamentally changing how products get built. Moving from opinion-driven development to evidence-driven development. From "I think users want this" to "7 users explicitly told us they need this and here's exactly what they said."

That's the world I want to live in. Where great products win because they listen to users, not because they have the best internal politics or the loudest stakeholder.

Why We're Actually Doing This

From that boxing gym four years ago to here, nothing went according to plan.

We failed at a bunch of businesses. Learned a ton from startups that went nowhere. Watched teams make the same product mistakes over and over. Finally found a problem that was worth obsessing over.

Aligno exists because we lived this exact pain at OmniSynkAI. We were drowning in user feedback we couldn't use. We were making product decisions based on vibes when we had actual data sitting right there. It drove me insane.

I kept thinking: if we're struggling with this, and we're technical founders who care deeply about talking to users, then what chance do other teams have?

So we built Aligno. For us first, honestly. Then we realized everyone needs this.

If you're tired of guessing what to build next, tired of user feedback scattered across Google Drive and Notion and Slack and your brain, tired of shipping features nobody uses while the feature everyone wants sits buried in some recording from three weeks ago—we built this for you.

Because here's what I truly believe: great products don't come from great guesses. They don't come from building what sounds cool or what the founder wants or what the loudest executive demands.

Great products come from listening to users and actually acting on what they tell you.

That's it. That's the whole game.

We just made it way easier to play.

---

If this sounds like you, check out Aligno. We'd love to help you stop guessing and start building what users actually want.