
CONTINUITY — When Responsibility Changes, Context Shouldn’t
🔄 We solve a simple problem: when work changes hands, context shouldn’t get lost. 🤖 Using Amazon Bedrock, we transform unstructured notes into actionable work states. ☁️ Built with Next.js, FastAPI, DynamoDB, S3, Lambda & EventBridge.
In modern workplaces, tasks rarely stay with one person from beginning to end.
Employees move between projects, teams change, responsibilities are reassigned, and people leave organizations. When this happens, the challenge is not always the loss of information.
The bigger problem is the loss of context.
What was completed?
What is still pending?
What was promised to a client?
What is blocking progress?
Which deadline is approaching?
And most importantly — what should the next person do?
This is the problem we wanted to solve with CONTINUITY.
🚀 Introducing CONTINUITY
CONTINUITY is an AI-powered operational continuity engine designed to preserve the state and context of ongoing work when responsibility changes.
Instead of simply transferring a task from one employee to another, CONTINUITY transfers the context behind the work.
The goal is simple:
When responsibility changes, important work should not lose its context.
🧩 The Problem We Identified
Consider a simple situation.
An employee working on a project writes:
"The payment API is completed, but webhook handling is still pending. Finance hasn't approved the discount yet, and I promised the client the revised version before Friday."
For the person who originally wrote this, the context is obvious.
But for someone taking over the work, it raises several questions:
- What has already been completed?
- What is still unresolved?
- Is there a blocker?
- Was something promised to the client?
- What is the deadline?
- What should I do first?
The information exists, but it is unstructured.
That is where CONTINUITY steps in.
🤖 From Unstructured Notes to Operational State
The first employee can create a handoff by simply pasting existing work notes or uploading supporting evidence.
CONTINUITY uses Amazon Bedrock to analyze the information and extract meaningful operational elements such as:
- Completed work
- Unresolved items
- Commitments
- Blockers
- Deadlines
- Exceptions
- Next actions
The previous example can therefore become:
Completed: Payment API
Unresolved: Webhook handling
Commitment: Revised version before Friday
Blocker: Finance approval
Next Action: Follow up with Finance
The important difference is that we are not simply generating a summary.
We are converting unstructured information into a structured representation of work state.
🛡️ "AI Extracts and Explains. Code Decides and Enforces."
One of the key architectural principles behind CONTINUITY is that AI should not have unrestricted authority over operational decisions.
The AI is responsible for understanding the information and extracting context.
The Policy Engine is responsible for deterministic decision-making.
For example:
- If a deadline has already passed → OVERDUE
- If a deadline is approaching while a blocker is active → AT RISK
- If required information is missing → the case can be flagged for attention
This separation makes the system more predictable and controllable.
Instead of allowing an AI model to independently determine the operational state, CONTINUITY uses AI for interpretation and deterministic code for enforcement.
🔄 The Handoff
Once the first employee reviews and confirms the generated Continuity Case, responsibility can be transferred to the next employee.
The new owner doesn't have to search through old conversations, documents, or scattered notes just to understand what happened.
They receive a structured Continuity Queue containing the information that matters:
📌 What was completed
📌 What remains unresolved
📌 What is blocked
📌 What was promised
📌 Important deadlines
📌 Recommended next actions
They can also access the original evidence, keeping the AI-generated information traceable back to its source.
🏗️ How We Built It
CONTINUITY combines AI extraction with a deterministic operational layer.
Frontend
Next.js
Provides the interface for creating handoffs, reviewing Continuity Cases, and managing the Continuity Queue.
Backend
FastAPI
Handles APIs, business logic, case processing, and communication between the different components.
AI Layer
Amazon Bedrock
Used to extract structured operational information from unstructured work notes and supporting evidence.
Operational State
Amazon DynamoDB
Stores the structured Continuity Cases and their current operational state.
Evidence Storage
Amazon S3
Preserves the original supporting evidence so extracted information remains traceable.
Automation
AWS Lambda + EventBridge Scheduler
Automates deadline evaluation and allows the system to continuously evaluate cases as their deadlines approach or pass.
Decision Layer
Deterministic Policy Engine
Applies predefined rules to operational information rather than relying entirely on AI-generated decisions.
🔐 Why Evidence Matters
One of the design principles we focused on was traceability.
AI can extract useful information, but users should still be able to understand where that information came from.
That's why CONTINUITY preserves the original evidence alongside the structured operational state.
This creates a relationship between:
Original Evidence → AI Extraction → Policy Evaluation → Current State → Next Action
This makes the system more transparent than simply presenting an AI-generated summary.
🆚 More Than an AI Summarizer
A traditional summarizer might tell you:
"This is what happened."
CONTINUITY aims to tell you:
"This is the current state of the work, this is what could be lost, and this is what the next owner needs to do."
That difference is at the heart of the project.
We are not trying to replace task-management systems.
We are addressing the context gap that appears when responsibility changes.
☁️ Architecture at a Glance
Employee → CONTINUITY → Amazon Bedrock → Structured Case → Policy Engine → Continuity Queue
Alongside this flow:
Original Evidence → Amazon S3
and
Operational Case State → DynamoDB
while
AWS Lambda + EventBridge Scheduler → Automated Deadline Evaluation
Together, these components create a system that combines AI understanding with deterministic operational control.
💡 What We Learned
Building CONTINUITY reinforced an important idea for us:
AI is powerful at understanding unstructured information, but important operational decisions benefit from deterministic rules and clear boundaries.
The most useful AI systems aren't necessarily the ones that give AI the most control.
They are the ones that give AI the right responsibility.
For CONTINUITY:
AI understands.
Code validates.
Policies decide.
Evidence provides traceability.
People remain in control.
🔗 Project Repository
The complete project, implementation details, and source code are available here:
🎯 Final Thought
Employee transitions are inevitable.
People change teams.
Projects change owners.
Responsibilities move.
But the context behind important work shouldn't disappear with the person who owned it.
That is what we built CONTINUITY to address.
When responsibility changes, important work should not lose its context.
👥 Team Court of Owls
We built CONTINUITY as a team to explore how AI and AWS technologies can be combined with deterministic engineering principles to solve a practical operational problem.
Thank you for taking the time to learn about our project.
CONTINUITY — Making sure important work survives the handoff.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article