THE RESET | Day 2: Product Refining

February 15, 2026

I'm writing "THE RESET", a series of articles to document my journey as I'm building my new venture and scaling it from 0 to $1M ARR. Last time we went through what I knew, who my target avatar should be, and what I should sell generally.

Disclaimer

The content provided in this series is designed to provide helpful information on the subjects. I am not responsible for any actions you take or do not take as a result of reading this series, and I'm not liable for any damages or negative consequences from action or inaction to any person reading or following the information in this series.

Today I want to focus on product refining, competitor research, solutions priority, and the final offer.

1. Product Refining

Yesterday I landed on what I want to build. But "build a skill graph platform" is vague. Today I'm going to sharpen the blade.

The best way I can describe this product is: the love child of Obsidian.md and roadmap.sh.

If you haven't used them:

• Obsidian is a markdown-based knowledge tool where you write notes and they form a graph. Every note links to other notes. Over time you build this interconnected web of everything you know. It's beautiful. It's powerful. And it's personal — your knowledge, your structure, your graph.
• roadmap.sh is the opposite end. It's community-driven developer roadmaps — visual dependency trees that show you exactly what to learn and in what order. Want to become a backend developer? Here's the path. Step by step. Prerequisite by prerequisite. You can see where you are and what's next.

Now imagine combining them.

What I’m actually building

From Obsidian: You write and import your own knowledge. Markdown. Your docs, your frameworks, your internal systems. It lives in a graph where everything connects to everything else. Bidirectional links. Relationships. Context.

From roadmap.sh: That knowledge isn't just stored — it's structured. Dependencies. Prerequisites. A visual path from "knows nothing about this" to "can teach it to others." Progress tracking. Clear "what to learn next."

What neither of them does: Team visibility. Obsidian is personal. roadmap.sh is generic. Neither of them lets a team leader see "where does my team stand on THIS knowledge, right now?"

That's the product:

Write your knowledge like Obsidian. Structure it like roadmap.sh. See your team's gaps in real time.

What the leader actually gets

Not "features." Not "technology." What does the leader get?

• Import your existing docs (Notion, Google Docs, PDFs, markdown) or write directly on the platform — like Obsidian, but for the whole team
• AI decomposes the content into structured, dependency-ordered steps — like roadmap.sh, but for your knowledge, not generic paths
• Team dashboard showing exactly where every member stands — the thing neither tool gives you
• Automatic gap diagnostics ("60% of your team is missing K8s foundations")
• Personalized learning paths for every team member, generated from the dependency graph
• Private + public knowledge in the same graph — your internal framework next to public skills
• Milestone-based progress (not "video completed")
• Time-to-proficiency estimates per member and team-wide

But here's the thing I realized — the most important thing is not the feature list. It's the core loop:

Write/Import → AI Decomposes → Review & Link → Team Learns → Dashboard Shows Gaps

If that loop works, everything else is derived.

• Gap diagnostics? Calculated from the graph.
• Learning paths? Generated from dependencies.
• Time estimates? Computed from positions.

The decomposition engine IS the product. Everything else falls out of it.

Obsidian proved people will write in markdown if the graph is good enough. roadmap.sh proved people will follow structured paths if the dependencies are clear. I'm betting that combining them — with AI doing the decomposition — and adding team visibility on top is the unlock nobody's built yet.

2. Competitor Research

Before building anything, I need to know who else is in this space. But here's how I think about competitor research — and it's different from what most people do:

I don't care what competitors do well. I care about where they fail. What their users complain about. What people are begging for in forums, reviews, and Reddit threads that the product team never ships. Because that's where the opportunity lives.

If you study what competitors do right, you end up building a slightly better version of someone else's product. If you study where they fail — where their users are frustrated, stuck, or leaving — you find the gaps nobody's filling. And then you don't compete. You build the thing they can't.

So that's what I did. I went through every major category and asked one question: where are users screaming?

Where wikis fail their users

Tools: Notion, Confluence, Google Docs

The complaint isn't "Notion is ugly" or "Confluence is slow." The complaint is deeper:

• "I wrote everything down. Nobody read it." — Knowledge goes in, nothing comes out. No structure, no sequence, no "what should I read first?"
• "I have no idea if anyone actually understood it." — Wikis store documents. They don't tell you who read it, who understood it, or who can actually do it.
• "Our Notion has 200 pages. New hires don't know where to start." — No dependencies, no paths, no "learn this before that."

The failure: Wikis are filing cabinets. They store. They don't teach, track, or surface gaps.

What I'm doubling down on: Import those same docs → AI structures them into dependency-ordered steps → the team leader sees who's completed what. Same knowledge, completely different experience.

Where LMS platforms fail their users

Tools: Udemy, Pluralsight, Coursera, LinkedIn Learning

• "Everyone 'completed' the course. Half of them can't do the job." — Video completion ≠ competency. Watching ≠ knowing.
• "The courses are generic. Our stack is unique." — There's no Udemy course for "how our billing system works" or "our custom deploy pipeline."
• "I can see individual accounts but not team readiness." — No team-wide view. No "are we ready to ship this?"
• "No prerequisites. People jump into Kubernetes without knowing networking." — No dependency graph. No way to express "learn A before B."

The failure: LMS platforms sell content. They don't map competency, handle private knowledge, or show team gaps.

What I'm doubling down on: Milestone-based progress (not "video watched"). Private knowledge in the same graph. Prerequisites enforced by the dependency model. Team dashboard as the primary view.

Where Obsidian fails its users

This one's closer to home because I love Obsidian. But that's exactly why I studied where it breaks.

• "It's my knowledge. Nobody else can see it." — Beautiful personal graphs with zero team visibility. Your manager can't see what you know. You can't see what your team knows.
• "There's no 'learn this before that.'" — Notes link to notes, but there's no dependency model. No "you need Docker before Kubernetes." No structured paths.
• "I have 500 notes. I have no idea what I'm missing." — No gap diagnostics. No "here's what you haven't covered yet."

The failure: Obsidian is the best personal knowledge tool that exists. But personal is the limitation. No team layer. No structure beyond what you manually create. No progress tracking.

What I'm doubling down on: Keep the Obsidian-style writing experience (markdown, graph, your knowledge). Add automatic structure (AI decomposition into dependency-ordered steps). Add the team layer (dashboard, gap diagnostics, progress tracking).

Where roadmap.sh fails its users

roadmap.sh is brilliant. But it has clear edges:

• "The paths are generic." — "Backend Developer," "DevOps," "Frontend." These are community defaults. Your internal billing system? Your custom deploy pipeline? Your ML infrastructure? Not on there. Never will be.
• "I can track my progress. My manager can't." — Individual progress only. No team dashboard. No "where does my team stand?"
• "I can't add my own knowledge." — It's read-only paths built by the community. You can't import your docs, write your own, or create custom steps.

The failure: roadmap.sh nails structure and dependencies for generic skills. But it can't handle private knowledge, custom paths, or team visibility.

What I'm doubling down on: Keep the structured, dependency-ordered paths. Make them customizable — import your docs, write your knowledge. Add team-wide tracking on top.

The pattern

Every competitor fails in the same places:

| Failure | Notion | Udemy | Obsidian | roadmap.sh |

|-------------------------|--------|-------|----------|-----------|

| No team visibility | ❌ | ❌ | ❌ | ❌ |

| No private/custom knowledge | ✅ | ❌ | ✅ | ❌ |

| No dependency structure | ❌ | ❌ | ❌ | ✅ |

| No gap diagnostics | ❌ | ❌ | ❌ | ❌ |

| No AI decomposition | ❌ | ❌ | ❌ | ❌ |

Look at that table. Team visibility: 0 for 4. Gap diagnostics: 0 for 4. AI decomposition: 0 for 4. These aren't features people don't want. These are features nobody has built.

That's the move. Don't build a slightly better wiki or a slightly better LMS. Build the thing their users are begging for that they structurally cannot deliver.

That's what makes this a Category of One.

The decision for the buyer isn't "us vs. Notion" or "us vs. Obsidian" or "us vs. roadmap.sh." It's "us vs. continuing to have no idea what your team knows."

3. Solutions Priority

I listed out every problem our target avatar faces. Every single one. I came up with 18.

Not 5. Not 10. 18 problems.

And I organized them into three phases:

• Before they try to solve it
• During their attempt with existing tools
• After — even if they partially succeed

Here are a few that hit hardest.

Before

• "I wrote it all down in Notion. Nobody read it."

→ Import existing docs. AI decomposes them into structured steps. Structure without rewriting.

• "I have to ask people 1:1, and they overestimate their skills."

→ Team dashboard shows every member's level on every step. Real-time. No self-reporting.

• "We found out nobody understood the auth flow when it broke at 2AM."

→ Gap diagnostics surface missing foundations before deployment.

During

• "Everyone 'completed' the Kubernetes course. Half of them can't deploy a service."

→ Progress is milestone-based. "Completed K8s" means "deployed a service and configured networking."

• "Our internal framework isn't on Udemy."

→ Import internal docs or write them on the platform. AI decomposes them into private skill nodes. Same graph, scoped to your team.

After

• "The board asks 'when will the team be ready?' I have no answer."

→ Graph calculates estimated time from current position to target proficiency, per member and team-wide.

• "HR asks for ROI on our L&D budget. I have nothing."

→ Dashboard becomes the proof. "Before: 2/8 could handle production deployments. After 6 weeks: 7/8."

If you can describe someone's pain better than they can describe it themselves, they automatically believe you have the solution. That's why every problem above is written in their words, not mine.

4. The Value Math

Before I set a price, I need to understand what solving this problem is actually worth to the buyer.

For a team of 25 engineers at $150K average salary:

```text

Wasted L&D spend: $30,000/year

One preventable incident/year: $25,000 (conservative)

One engineer who leaves for

lack of growth opportunities: $75,000 (replacement cost)

───────────────────────────────────────

Total recoverable value: $130,000/year