AWS Builder Center
AIdeas: Today - AI-Native Knowledge Layer for Engineering Teams

AIdeas: Today - AI-Native Knowledge Layer for Engineering Teams

A CLI-first knowledge platform where capturing what you know takes five seconds and finding what your team knows takes one query. Built serverless on AWS Bedrock, Lambda, and DynamoDB for near-zero cost.

My Vision

Every developer carries knowledge in their head that their team never sees. That insight about Lambda cold starts you figured out at 2am. The DynamoDB access pattern you spent three days learning. The AWS Bedrock prompt structure that finally worked. It lives in your brain, maybe a Slack message, and then it's gone.
Today is my answer to that problem: a CLI-first, AI-powered knowledge platform where capturing what you know takes five seconds and finding what your team knows takes one query.
``` today learned "Lambda cold starts drop 80% when you keep deployment packages under 50MB and use provisioned concurrency for latency-sensitive paths"
today ask "How do I reduce cold start times in production?" → 94% match: Lambda cold starts drop 80%... → Expert:  sarah@team.com  (AWS, Serverless)
today experts "DynamoDB single-table design" →  ben@todaycli.com  - 12 entries, avg expertise 8.4/10 ```
The platform combines a CLI tool, seven AWS Lambda functions, a web dashboard with a live knowledge graph, and an AI enrichment pipeline running entirely on AWS Bedrock. Everything runs serverless, everything scales to zero, and the entire architecture fits comfortably within AWS Free Tier limits.



Why This Matters

Picture this: Maya joins a 12-person backend team on a Monday.
By Wednesday she's blocked. The service she's been asked to extend makes an unusual assumption about DynamoDB read consistency that isn't documented anywhere. She spends four hours searching the codebase, reading old pull requests, and eventually finds a Slack message from eight months ago where James mentioned it in passing. James is now on a different team.
On that same Wednesday, in a parallel world where her team has been using Today for six months: Maya types "today ask why does the payments service use eventual consistency for reads" and gets back a 91% match. It’s an entry James wrote the day he figured it out, with an AI-generated summary, tagged to the right topics, rated at expertise level 7. She's unblocked in 30 seconds. James is never interrupted. That's the compounding effect. Every entry captured makes the next new hire faster. Every expert identified reduces the interruption tax on senior engineers. The knowledge graph grows denser with every "today learned" until the team's institutional memory becomes genuinely searchable.
The numbers behind that scenario:
The 2024 Stack Overflow Developer Survey, covering over 65,000 developers worldwide, puts hard numbers on a problem most engineering teams already feel intuitively:
  • 61% of developers spend over 30 minutes every day just searching for answers to technical questions
  • 45% encounter knowledge silos that actively block their work on a frequent basis
  • 30% say knowledge silos disrupt their productivity 10 or more times per week; twice a day on a five-day workweek
  • 53% of developers and managers agree that "waiting on answers to questions often causes interruptions and disrupts my workflow"
  • 48.8% of developers regularly answer questions they have already answered before
Add the human layer: a Blind survey of over 10,000 tech workers found that 57.5% have experienced imposter syndrome. Fear of appearing incompetent is not a fringe concern: it is the default experience for the majority of developers.
These two problems compound each other. Knowledge exists in the team but it is not findable. And the people who need it most are often the least likely to ask for it directly. The result is wasted hours, repeated mistakes, senior engineers permanently interrupted by questions that should have been answered once, and new developers who take months to reach productivity when they could take weeks.
Today attacks both problems at the same time. When knowledge is captured continuously and searchable instantly, developers can explore privately before asking, senior engineers stop being bottlenecks, and the collective intelligence of the team becomes accessible to everyone.



How I Built This

Starting with Kiro

I used Kiro, AWS's AI-powered IDE, to architect the entire system before writing a line of production code. This was genuinely transformative. I worked with Kiro to produce four detailed specification documents covering:
  • 14 functional requirements across the core platform, CLI UX, authentication, and web application
  • 30 correctness properties for property-based testing with fast-check
  • Full data models, API contracts, and Mermaid architecture diagrams
  • A complete testing strategy with specific scenarios per requirement
Kiro didn't just generate boilerplate - it helped me reason through multi-tenant data isolation, the two-stage search architecture, and the trade-offs between different DynamoDB access patterns. Having structured specs meant every Lambda function had explicit requirements to validate against.



Architecture

The system is built as a TypeScript monorepo with four packages:
  • shared (types, DynamoDB client, Bedrock client, utilities)
  • lambdas (seven Lambda functions)
  • cli (the today CLI tool)
  • web-app (React dashboard)

AWS services used:

Service
Role
AWS Bedrock (Claude 3 Haiku)
Topic inference, content enrichment, team insights generation
AWS Bedrock (Titan Embeddings v2)
1024-dimensional semantic vectors for similarity search
AWS Lambda
Seven functions: knowledge-ai, api-router, auth-handler, post-confirmation, teams, insights, secrets
Amazon DynamoDB
12 tables with team-scoped partition keys across all entities
Amazon Cognito
JWT authentication with post-confirmation trigger for automatic team provisioning
Amazon API Gateway
REST API with Cognito authorizer
Amazon S3 + CloudFront
Web dashboard hosting
AWS Secrets Manager
Zero-knowledge encrypted team secrets
Amazon SES
Email verification
AWS Certificate Manager
TLS for custom domain



Why Not Just Slack + an AI Bot?

It's a fair question. Here's the honest answer:
Every team already has Slack, Confluence, Notion, or a shared wiki. Some have started pointing a GPT at their documentation. None of them solve the capture problem.
The issue isn't retrieval: it's the moment of learning. A developer figures out why a particular Lambda configuration was causing silent failures at 11pm on a Tuesday. They fix it. That knowledge exists for approximately 72 hours before it becomes inaccessible to the rest of the team. Confluence requires logging in, navigating to the right space, writing a page, tagging it correctly. Nobody does that at 11pm. "today learned" takes five seconds in the terminal they already have open. That difference in friction is the difference between knowledge that compounds and knowledge that disappears.
Beyond capture, the architecture solves problems that "GPT over your docs" doesn't:
  • Topic-scoped search: queries are filtered to relevant entries before similarity is computed, not after. A question about Lambda never touches your Python entries. Cheaper, faster, more precise.
  • Expertise scoring: the system tracks not just who wrote about a topic, but at what level of sophistication, so it surfaces genuine experts rather than whoever wrote the most entries.
  • Team isolation: every query, every entry, every result is scoped to your team's partition. There is no shared index and no cross-team data leakage, by design.
  • Zero-knowledge secrets: sensitive team knowledge (API patterns, architecture decisions, internal tooling) can be stored with AES-256-GCM client-side encryption. The server never sees the plaintext.
The knowledge graph isn't a feature bolted on top; it's the output of a system that continuously indexes relationships between topics as entries are created. It grows and self-organises without anyone managing it.

The Search Architecture

The most technically interesting decision was the two-stage search pipeline. When a user runs:
`today ask` "How do I handle cold starts?"
Stage
What happens
AWS service
1. Topic Inference
Claude maps the question to topic IDs from your team's taxonomy
Bedrock · Claude 3 Haiku
2. Index Query
PK lookup on topic_entries table. No table scan
DynamoDB
3. Fetch + Embed
BatchGet the matched entries, generate question vector
DynamoDB + Titan Embeddings v2
4. Rank + Return
Cosine similarity on the filtered subset only, not the full knowledge base
Lambda
This approach means similarity is only computed on semantically pre-filtered entries. A question about Lambda never touches DynamoDB entries or Python. The topic_entries table is a denormalized index maintained at write time - every captured entry writes one record per inferred topic.



AI Enrichment Pipeline

Every captured entry goes through a three-step Bedrock pipeline:
  1. Topic inference - Claude selects from the team's existing topic taxonomy (or flags new ones)
  1. Embedding generation - Titan Embeddings v2 generates a 1024-dimensional vector stored with the entry
  1. Content enrichment - Claude generates a plain-language summary and assigns an expertise level on a 1–10 scale with detailed per-band criteria
The expertise scale matters for expert discovery - the system identifies team members not just by what topics they write about, but by the sophistication level of their contributions. Someone with 20 entries at expertise 8–9 on DynamoDB is surfaced differently from someone with 20 entries at expertise 3–4.



CLI Design

The CLI uses Commander.js and Inquirer.js with a custom styling layer (chalk + ora).

Key commands:

today login # Cognito auth with email/password today learned <text> # Capture knowledge → AI enrichment → stored today ask <question> # Semantic search with similarity scores today experts <topic> # Expert discovery ranked by score today secrets # AES-256-GCM encrypted team secrets (client-side) today teams create # Multi-team workspace management today demo # Populates 5 sample entries + runs search + expert demo
The today demo command deserves a mention - it's a self-contained walkthrough that creates realistic sample entries, runs a semantic search, and demonstrates expert discovery, letting new team members see the value immediately without needing existing data.

Automatic workspace context

When you run today learned or today ask inside a git repository, the CLI silently runs git remote get-url origin, normalizes it to a canonical github.com/org/repo identifier, and passes it with the request. Entries are tagged to the repository they were captured in, and search results from the same repo are boosted and labelled [this repo] in the output. No flags or config the tool will just know where you are.



Web Dashboard

The React 19 web application (Vite, Tailwind CSS 4.1, React Router 7) provides:
  • Dashboard with live stats (entries, members, topics, workspaces), semantic search with inline results
  • Knowledge graph using React Flow - nodes are topics, edges are co-occurrence relationships, entry count controls node size
  • My Entries - full entry history with AI summaries, expertise levels, copy-as-Markdown/JSON export
  • Workspaces - namespace entries by project or squad
  • Team Insights - AI-generated weekly health reports (knowledge velocity, emerging experts, topic gaps)



Demo

Below are some screenshots of the application. Alternatively, you can watch a walkthrough of the project here:  https://youtu.be/YUpvecTQd0E 
If you want to get hands on, then sign up here:  https://todaycli.com 
Logging in and adding an entry:

Asking the system a question using natural language:

Finding an expert with the 'experts' command:

Knowledge-graph in the web dashboard:

AI generated team insights:




Costs & Scalability

The platform is designed to operate at effectively zero cost for small teams. Seven of the nine AWS services used are covered by permanent Free Tier allowances. The only services without permanent free tier coverage are AWS Bedrock and API Gateway, and their costs remain negligible at small-team scale.
Permanent AWS Free Tier Coverage
Service
Free Allowance
Status at 20 People
AWS Lambda
1M requests/month
Well within
Amazon DynamoDB
25 GB + 25 WCU/RCU
Well within
Amazon Cognito
50,000 MAU
Well within
Amazon S3 + CloudFront
5 GB, 1 TB transfer
Well within
Amazon SES
200 emails/day
Well within

Primary Cost Driver: AWS Bedrock

AWS Bedrock does not include a permanent free tier. However, per-token pricing is sufficiently low that costs remain minimal.

Cost Breakdown

Operation
Tokens Consumed
Estimated Cost
Capturing one entry (topic inference + enrichment + embedding)
~1,000 tokens
~$0.0004
Running one query (topic mapping + embedding)
~600 tokens
~$0.0002
500 entries + 500 queries/month (20-person team)
~800K tokens
~$0.30/month
At a 50-person team performing approximately 1,500 entries and 3,000 queries per month, total platform cost is estimated at $2–5 per month, driven almost entirely by Bedrock usage.

ROI

Metric
Value
Platform cost at 50 people
~$5/month
Value of one unblocked developer-day prevented per week
~$2,500/month
ROI ratio
~500:1
Cost per knowledge entry
< $0.01

What I Learned

Kiro changes how you think before you type. Starting with specifications rather than code forced me to make architectural decisions consciously rather than accidentally. The 30 correctness properties became a genuine quality bar - not just a list of things to test, but a contract I held myself to. Several design choices I initially skipped (like the two-stage search architecture and the topic_entries denormalized index) emerged from working through the properties with Kiro before any implementation existed.
AWS Bedrock is more capable than you expect at the free tier. Claude 3 Haiku handles topic inference and content enrichment with impressive consistency, and Titan Embeddings v2 produces semantic vectors that make the similarity search feel genuinely intelligent. I initially planned to use OpenAI, but the AWS-native path with Bedrock gave me better integration, simpler IAM authorization, and no third-party dependencies.
DynamoDB single-table thinking is a skill. My initial submission mentioned RDS - the building phase changed that. DynamoDB's team-scoped partition key pattern (team_id on every table) gave me multi-tenancy essentially for free, and the topic_entries index table pattern (write one record per topic at capture time, query by topic at search time) eliminated the need for any table scans in the hot search path. It took real design effort but the result is something that would scale to millions of entries.
The psychology of developer tools matters more than the features. The most useful feedback during building was from developers who said the CLI felt "like it was part of my workflow" rather than "another tool to switch to." Speed matters - if capturing a learning takes longer than 15 seconds, it won't happen. The design discipline of keeping every interaction to a single command with no required flags was as important as any technical decision.
Serverless architecture is genuinely free tier-compatible at a meaningful scale. Seven Lambda functions, twelve DynamoDB tables, Cognito, API Gateway, CloudFront, S3 - the entire production system costs effectively nothing at team scale. That's not a limitation of the competition rules; it's actually the right architecture for a product that needs to prove value before it can justify infrastructure spend.


Built with AWS Bedrock, Lambda, DynamoDB, Cognito, API Gateway, S3, CloudFront, SES, Secrets Manager - and architected with Kiro.



Further Reading

Stack Overflow, Your developers deserve better: Insights from the 2024 Developer Survey, 2024;  https://stackoverflow.co/internal/resources/your-developers-deserve-better-insights-from-the-2024-developer-survey/ .
Statista, Daily time developers spend searching for solutions, 2024;  https://www.statista.com/statistics/1401435/daily-time-spent-searching-solutions-developers-globally/ 
Eira May, What we talk about when we talk about impostor syndrome, 2023;  https://stackoverflow.blog/2023/09/11/what-we-talk-about-when-we-talk-about-imposter-syndrome/ 
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article