AIdeas: Organizational Memory Decay AI
Prevent knowledge loss before it's a crisis. OMDA uses Amazon Bedrock on AWS to detect single points of failure and auto-generate knowledge capture docs.
App Category: Workplace Efficiency
Team Members: @riyar0109
Team Members: @riyar0109
My Vision
What happens when your only payments engineer goes on vacation and suddenly production breaks?
You scramble. You dig through Slack. You reverse engineer code. You realize that three months of critical knowledge just walked out the door and nobody noticed until it was too late.
This scenario plays out in engineering teams every day. The senior developer who's the only one who understands the authentication flow. The DevOps engineer who knows why that one deployment script has a mysterious sleep statement. The product manager who remembers the business logic behind the pricing algorithm. When these people are unavailable whether due to vacation, departure, or simply being overwhelmed their knowledge becomes a single point of failure.
The problem isn't just about documentation. It's about organizational memory decay: the gradual, silent erosion of critical knowledge that happens when information lives in too few heads. Unlike server crashes or budget overruns, knowledge loss is invisible until it's catastrophic. By the time you realize you need that knowledge, the person who had it is gone.
OMDA (Organizational Memory Decay AI) is an early warning system that predicts and prevents knowledge loss before it happens. Think of it as a health monitoring system for your organization's collective intelligence. Instead of waiting for someone to leave and scrambling to document what they knew, OMDA continuously analyzes workplace signals meeting transcripts, chat messages, task ownership records, code references to detect when critical knowledge is concentrated in too few people.
How It Works:
- Ingest: Upload workplace signals (Slack exports, meeting notes, task data)
- Extract: AI identifies knowledge entities, people, and ownership patterns
- Analyze: Calculate Knowledge Fragility Scores (0-100) for every system and process
- Intervene: Auto-generate targeted questions and documentation to preserve knowledge
- Visualize: Interactive dashboard shows knowledge risks in real time
Knowledge loss is predictable and preventable. By treating organizational memory as a measurable asset with quantifiable risk, we can intervene before it's too late. Built on AWS with Amazon Bedrock Nova Pro at its core, OMDA transforms invisible knowledge risks into actionable metrics that executives can understand and engineers can act on.
Live Demo: https://dmj9awlqdvku4.cloudfront.net
GitHub Repository: https://github.com/SamyakJ05/OMDA
Test Credentials: test@omda.demo / TestPass123!
GitHub Repository: https://github.com/SamyakJ05/OMDA
Test Credentials: test@omda.demo / TestPass123!
Why This Matters
Every engineering team has a "bus factor" problem the number of people who need to get hit by a bus before your project is doomed. For critical systems, that number is often one. When that person leaves, gets promoted, or goes on vacation, the organization faces a knowledge crisis. The real cost isn't just the salary of a replacement it's the 3-6 months of institutional knowledge that walks out the door, the repeated explanations that waste 20% of engineering time, and the production incidents that could have been prevented.
Traditional knowledge management tools wikis, documentation systems, Confluence pages are reactive. They assume someone will proactively document what they know. But documentation is always out of date, always incomplete, and always written after the knowledge has already become critical. OMDA flips this model. Instead of waiting for documentation, it continuously monitors workplace signals to detect knowledge concentration in real-time. It's predictive, not reactive. It identifies single points of failure before they become crises.
Real World Impact:
- Fintech startup: Payment system owned by one engineer who goes on vacation, production breaks. OMDA detects the concentration risk weeks in advance and generates knowledge capture questions before she leaves, preventing a $50,000 loss.
- Growing SaaS team: Authentication system built 5 years ago by a departed engineer. OMDA flags it as a "ghost system" critical infrastructure with zero living knowledge triggering documentation interventions that reduce a 6-week reverse engineering effort to 2 weeks.
- Remote engineering team: Knowledge fragments across time zones, leading to duplicate work. OMDA detects that European and US teams are building the same caching layer independently, saving 11 weeks of wasted engineering effort.
Knowledge loss is the highest leverage productivity problem that most teams completely ignore. We optimize build times, automate deployments, and tune database queries but we let critical knowledge silently evaporate. OMDA makes organizational memory a first-class concern, measurable and manageable like any other engineering metric.
How I Built This
OMDA is built as an event driven serverless pipeline on AWS, designed to scale from zero to thousands of signals per day without managing infrastructure. The architecture follows a clean data flow: ingest → extract → analyze → intervene → visualize.
Data Ingestion: Workplace signals are uploaded to Amazon S3 meeting transcripts, Slack exports, task data, code commits. S3 triggers an AWS Lambda function that validates the format, extracts metadata, and queues the signal for processing. This decoupled design handles bursty workloads without dropping data.
AI Extraction with Amazon Bedrock Nova Pro: The heart of OMDA is Amazon Bedrock with the Nova Pro model. When a signal arrives, an AWS Lambda function sends it to Amazon Bedrock with a carefully crafted prompt: "Extract all knowledge entities (systems, processes, concepts), people mentioned, and ownership signals." Nova Pro understands context out of the box, distinguishing between "Sarah mentioned the payment system" (weak signal) and "Sarah is the only person who understands how the payment retry logic works" (strong ownership signal). A second Lambda function analyzes these signals to identify ownership patterns and concentration risks.
Knowledge Graph Storage: All extracted entities and relationships flow into Amazon DynamoDB, organized across four tables: entities, relationships, historical scores, and interventions. DynamoDB's flexible schema handles evolving organizational knowledge, and DynamoDB Streams trigger downstream processing whenever the graph changes.
Fragility Scoring Algorithm: An AWS Lambda function computes a Knowledge Fragility Score (0-100) for every entity using three weighted components: Concentration (how many people understand this?), Repetition (how often is it referenced?), and Dependency (how many systems rely on it?). Scores map to risk levels: LOW (0-25), MODERATE (26-50), HIGH (51-75), CRITICAL (76-100). Scores are recalculated in real-time as new signals arrive.
Automated Interventions: When an entity crosses into HIGH or CRITICAL territory, OMDA automatically generates interventions using Amazon Bedrock Nova Pro. Three Lambda functions create targeted questions to extract tacit knowledge, ELI5 summaries for knowledge transfer, and micro-documentation guides. All interventions are stored in DynamoDB and surfaced in the dashboard for team review.
Frontend Dashboard: Built with React, TypeScript, and D3.js, the dashboard provides an interactive interface for exploring organizational knowledge health. Key views include a force directed knowledge graph visualization (nodes sized by fragility score, colored by risk level), a sortable fragility scores table, a 30-day risk timeline showing score evolution, a drag-and-drop signal upload interface, and an intervention workflow for answering AI-generated questions.
Authentication and Hosting: User authentication is handled by Amazon Cognito with secure session management. The frontend is hosted on Amazon S3 as a static site, served globally via Amazon CloudFront with HTTPS and sub 100ms latency worldwide.
Development: OMDA was built using Kiro, an AI-powered IDE that implements spec driven development. I wrote a detailed specification outlining requirements, design decisions, and implementation tasks. Kiro broke this into 22 major tasks and 86 sub-tasks, then executed them systematically. The spec driven approach prevented scope creep and ensured every feature had a clear purpose. From initial spec to working system took just 2 days.
OMDA leverages 10 AWS services: Amazon Bedrock (Nova Pro), AWS Lambda (9 functions), Amazon DynamoDB (4 tables), Amazon S3, Amazon CloudFront, Amazon Cognito, AWS CloudFormation, Amazon CloudWatch, AWS IAM, and Amazon API Gateway. The entire system runs for under $5/month within AWS Free Tier limits.
Demo
The live demo is available at https://dmj9awlqdvku4.cloudfront.net with test credentials (test@omda.demo / TestPass123!). Here's a walkthrough of the key features:
Screenshot 1: Login Page
Amazon Cognito authentication with email/password. Secure session management with automatic token refresh.
Screenshot 2: Hero Dashboard
Main dashboard showing real-time knowledge health metrics, interactive knowledge graph, and fragility scores table. The force directed graph visualizes knowledge dependencies with color coded risk levels.
Screenshot 3: Knowledge Graph Topic Selected
Interactive D3.js force directed graph with entity detail panel. Clicking a topic node reveals its Knowledge Fragility Score (92 - CRITICAL), score breakdown, ownership information, and AI-generated interventions.
Screenshot 4: Knowledge Graph Person Selected
Person node detail view showing "Single Point of Failure" warning. The graph highlights all systems dependent on this person, revealing organizational risk if they become unavailable.
Screenshot 5: Fragility Scores Table
Sortable table displaying all knowledge entities with scores 0-100. Columns show entity name, score, risk level, owner count, and last updated timestamp. Payment Processing shows CRITICAL score of 92 with only one owner.
Screenshot 6: Signal Upload Interface
Real-time signal processing interface. Users paste meeting transcripts, Slack threads, or task descriptions. Amazon Bedrock Nova Pro extracts entities, people, and ownership signals in seconds.
Screenshot 7: AI-Generated Interventions
Intervention workflow where Amazon Bedrock Nova Pro creates targeted questions to extract tacit knowledge from experts. Teams answer questions directly in the interface, creating micro-documentation automatically.
Screenshot 8: Risk Timeline
30-day historical risk timeline showing how fragility scores evolve over time. The Authentication System score dropped from 75 to 45 after successful knowledge transfer interventions measurable proof that interventions work.
What I Learned
Building OMDA taught me six critical lessons about AI-powered systems and organizational knowledge:
1. Prompt engineering is the new programming. The quality of Amazon Bedrock Nova Pro's entity extraction depended entirely on prompt design. Early versions extracted too much noise; refined prompts with explicit examples and structured output formats improved accuracy by 60%. The prompt became the most important code in the system.
2. Serverless scales effortlessly if you design for it. AWS Lambda's event driven model meant OMDA could handle 10 signals or 10,000 without code changes. But this required thinking in terms of events, not servers. Amazon DynamoDB Streams triggering downstream Lambda functions created a self scaling pipeline that felt like magic.
3. Knowledge graphs reveal hidden dependencies. Visualizing entities and relationships exposed patterns that tables and lists couldn't. The graph showed that the payment system wasn't just owned by one person it was a dependency for eight other systems, multiplying the risk. Graph thinking changes how you see organizational knowledge.
4. AI-generated interventions need human validation. Amazon Bedrock's questions were impressively relevant, but occasionally missed context or asked redundant questions. The intervention workflow had to support human review and refinement. AI augments human judgment; it doesn't replace it.
5. Metrics drive behavior. Once teams could see fragility scores, they started competing to reduce them. Gamification wasn't planned, but quantifying knowledge risk made it actionable. What gets measured gets managed even organizational memory.
6. Spec-driven development with Kiro was transformative. Writing a detailed specification before coding forced me to think through edge cases, data models, and user workflows upfront. Kiro's systematic execution of 86 sub-tasks eliminated the chaos of ad-hoc development. The result was cleaner code, fewer bugs, and faster delivery. I'll never go back to coding without a spec.
What's Next
OMDA demonstrates that organizational memory doesn't have to decay silently. With AI, serverless architecture, and the right metrics, knowledge loss becomes predictable and preventable transforming from an invisible crisis into a manageable operational concern.
The next evolution focuses on seamless automation and predictive intelligence. Real-time integrations with Slack, Microsoft Teams, Jira, and GitHub will eliminate manual signal uploads, turning every meeting transcript and code commit into automatic knowledge graph updates. Cross-team knowledge mapping will extend fragility scoring beyond single teams, revealing organizational blind spots where engineering owns the code but product owns the business logic. Predictive attrition risk will combine fragility scores with HR signals to forecast knowledge loss months before someone gives notice, enabling proactive transfer plans instead of reactive scrambling.
Amazon Bedrock Agents will evolve the system from extraction to conversation, asking follow-up questions and validating captured knowledge automatically. The AI becomes a knowledge interviewer, not just an extractor. A unified Knowledge Health Score will aggregate team-level fragility into a single executive metric, making organizational memory as measurable as uptime or deployment frequency.
The vision is clear: knowledge loss should be as preventable and measurable as any other operational risk. OMDA is the first step toward a future where institutional memory is preserved systematically, where expertise is distributed deliberately, and where no team ever loses critical knowledge because one person walked out the door. The technology exists. The architecture scales. The only question is whether organizations will treat knowledge as the strategic asset it truly is.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article