AIdeas: WhyBase - AI Powered Decision Memory for Teams
"Why do we use PostgreSQL?" nobody remembers. The decision was buried in a Slack thread 3 months ago. WhyBase automatically captures team decisions from Slack and GitHub using Amazon Bedrock, extracting the full story, who proposed what, which alternatives were debated, and why the final call was made, then answers "why did we decide this?" with source-backed context. It tracks how decisions evolve across tools and time, so the rationale is never lost.
App category
Workplace Efficiency
My Vision
Every team makes hundreds of decisions, scattered across Slack threads, GitHub issues, and meeting notes. Within weeks, the context behind those decisions fades. New hires ask "why do we use PostgreSQL?" and nobody remembers. Teams waste hours re-debating settled topics because the original rationale was buried in a Slack thread from three months ago.
WhyBase is an AI-powered decision memory system that automatically captures, understands, and preserves the full story behind every team decision.
It ingests conversations from tools your team already uses (Slack and GitHub), and uses AI to extract structured decisions complete with: who proposed what, which alternatives were debated, the pros and cons of each option, who made the final call, and the consensus type. When anyone asks "Why did we decide this?", WhyBase answers with source-backed context linking directly to the original discussions.
But WhyBase goes beyond simple search. It understands that decisions evolve over time. When a team revisits a topic months later, perhaps in a different tool entirely, WhyBase detects the connection, links the decisions together, and maintains a clear evolution chain showing how team thinking has changed and why.
What I built:
- Multi-source ingestion => Real-time webhooks from Slack threads and GitHub issues
- AI decision extraction => Structured extraction of decisions with alternatives, pros/cons, participant roles, and confidence scoring using Amazon Bedrock
- Discussion timeline => A visual replay of the conversation showing who said what and how the debate evolved toward a decision
- Natural language querying => Ask "why" questions in plain English and get source-backed answers with semantic vector search
- Cross-source decision linking => Automatic detection when the same topic is discussed across different tools, with evolution tracking
- Slack bot integration => Ask WhyBase questions directly in Slack with the
/whybaseslash command
Why This Matters
Decision context loss is one of the most expensive invisible problems in organizations. McKinsey found that executives spend almost 40% of their time on decisions and believe most of that time is poorly used. Only 37% of meetings actually result in a decision , and Bain & Company found a 95% correlation between decision effectiveness and top-tier financial performance. A
major driver of this waste? Teams re-discussing decisions that were already made because the original rationale was lost. This problem compounds as teams grow: every new hire means
another person who doesn't know why things were decided the way they were.
Current tools fail at this because:
- Chat search finds messages but not decisions, you still have to read through an entire thread to understand what was decided and why
- Documentation requires someone to manually write it, and it's always out of date
- Meeting notes capture what was discussed but rarely capture the alternatives that were rejected and why
| Approach | Find Decisions? | Captures "why"? | Automatic? | Track Evolution? |
|---|---|---|---|---|
| Slack search | No | No | No | No |
| Confluence/Notion | Sometimes | Sometimes | No | No |
| Meeting Notes | Sometimes | Rarely | No | No |
| WhyBase | Yes | Yes | Yes | Yes |
WhyBase solves this by making decision capture automatic and intelligent. Teams don't change their workflow, they keep discussing in Slack and GitHub as they normally do. WhyBase listens, understands, and remembers.
The workplace efficiency impact is clear: faster onboarding (new hires can query institutional knowledge from day one), reduced decision fatigue (no more re-debating settled topics), and better accountability (every decision has a clear owner and rationale).
How I Built This
Architecture
WhyBase is built as a TypeScript monorepo with five packages:
1
2
3
4
5
6
7
WhyBase/
├── apps/web — TanStack Start frontend (React, TailwindCSS)
├── apps/api — Hono API server (TypeScript, Bun runtime)
├── packages/db — Drizzle ORM schema + migrations
├── packages/mastra — AI orchestration (Mastra framework)
├── packages/shared — Shared types
└── prompts/ — LLM prompt templatesThe data flow works like this:
- Slack or GitHub sends a webhook when a conversation happens
- The API validates the signature, fetches the full thread, and stores the raw event
- The Mastra AI pipeline sends the conversation to Amazon Bedrock (Nova Pro) for structured decision extraction
- Amazon Titan generates a 1024-dimensional embedding for semantic search
- The extracted decision, with alternatives, pros/cons, participant roles, and discussion thread is stored in PostgreSQL with pgvector
- A link analyzer checks for similar existing decisions across all sources and creates evolution chains
- The frontend displays everything through the Decision Timeline, and users can ask natural language questions that are answered using vector similarity search
AWS Services Used
| Service | Usage |
|---|---|
| Amazon Bedrock (Nova Pro) | LLM for decision extraction — analyzing conversations and outputting structured JSON with alternatives, pros/cons, participant roles, confidence scores, and discussion annotations |
| Amazon Bedrock (Titan Embeddings V2) | Generating 1024-dimensional vector embeddings for semantic search across decisions |
| Amazon Lightsail | Hosting the full application stack (API + frontend + PostgreSQL) in a Docker environment |
Key Technical Decisions
Mastra AI Framework for orchestration => Mastra provided a clean abstraction over Bedrock, handling structured output with Zod schemas, retry logic, and agent composition. This let me define the extraction pipeline declaratively rather than writing raw API calls.
pgvector for semantic search => Instead of a separate vector database, I used pgvector as a PostgreSQL extension. This kept the architecture simple (one database for everything) while enabling cosine distance search for "Ask Why" queries and similarity detection for decision linking.
Prompt engineering for decision extraction => The extraction prompt is carefully designed to identify not just what was decided, but the full story: who proposed each alternative, the pros and cons discussed, participant roles (proposer, supporter, dissenter, decision maker), and a narrative discussion thread with annotated messages. Few-shot examples guide the LLM to produce consistent, structured output.
Cross-source decision linking => After each extraction, the pipeline searches for semantically similar decisions using vector distance. When a match is found, a separate LLM call classifies the relationship (related, evolves, reaffirms, contradicts) and generates a one-sentence context explaining the connection. This enables WhyBase to track how decisions evolve across tools and time.
Development with Kiro
I used Kiro (AWS's AI-powered IDE) to build the GitHub integration. Kiro generated a comprehensive design document including the webhook handler, signature validation, event normalization, and user resolution, following the same patterns established in the Slack integration. This accelerated the GitHub integration significantly, as Kiro understood the existing architecture and produced code that was consistent with the codebase conventions.
Demo
Watch WhyBase extract a real decision from a Slack thread and GitHub issue and answer "why did we choose this?" in real-time (5 min)
What I Learned
AI extraction requires iterative prompt engineering
The biggest challenge was getting consistent, high-quality decision extraction from messy real-world conversations. Early attempts produced either overly confident results (marking casual suggestions as firm decisions) or overly cautious ones (marking clear agreements as "undecided"). The solution was carefully calibrated confidence guidelines with concrete examples, teaching the LLM that informal agreement from multiple participants still counts as a decision, while a single person's suggestion without responses does not.
Decisions are living things, not static records
My initial design treated decisions as immutable facts. But real teams revisit decisions constantly, what was right in February might be wrong by June due to new information. Building the evolution chain feature (linking related decisions across sources and time) was the most architecturally complex feature, but it's also the one that makes WhyBase genuinely useful. The key insight: never overwrite old decisions. They were correct at their time. Instead, create a chain that shows how thinking evolved.
Bedrock's cross-region inference profiles require careful configuration
I spent time debugging Bedrock rate limits that turned out to be cross-region inference profile quotas set to zero. The lesson: always verify both model access and quota configuration when setting up Bedrock, and use direct model IDs during development to avoid cross-region complications.
Simple architecture wins
Running everything on a single Lightsail instance with Docker Compose (API + PostgreSQL + pgvector) was the right call for an MVP. The temptation to use separate managed services (RDS, ECS, Lambda) would have added complexity without meaningful benefit at this stage. pgvector as a PostgreSQL extension eliminated the need for a separate vector database while providing excellent semantic search performance.
The "wow" factor is in the human story
The most impactful feature isn't the AI extraction itself, it's the visual discussion timeline that shows the human story behind each decision. Users don't just want to know what was decided; they want to see the debate, the disagreements, the compromises, and the final call. Making the AI understand and present the human dynamics of team discussions is what transforms WhyBase from a search tool into a decision intelligence platform.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article