
Building FrameGuard: An AI-Powered Continuity Supervisor on AWS Serverless
FrameGuard is an AI-powered continuity assistant for filmmakers that compares takes, detects continuity issues in costumes, props, accessories, and scene details, and generates a structured report using AWS serverless services.
π¬ FrameGuard: Building an AI-Powered Film Continuity Assistant with AWS Serverless
Author: Ruthran Arulmani Built for: AWS Bharat Builds Tour 2026 / First Commit Hackathon Tags: #BharatBuilds #AWS #Serverless #Nextjs #AI #DynamoDB #S3
The Problem: Continuity Is Easy to Miss
In filmmaking, continuity refers to keeping visual and story details consistent between shots and takes.
A character may be wearing a particular shirt, holding a coffee cup, wearing a watch on one wrist, or standing next to a specific object. If one of those details changes between takes, the mistake may only become obvious during editing.
Traditionally, production teams rely heavily on script supervisors and manually captured reference photos to track these details.
But when a production generates hundreds or thousands of images and takes, manually comparing everything can become time-consuming.
That led me to a simple question:
Can AI help filmmakers identify continuity differences before they reach the edit?
For the AWS Bharat Builds Tour 2026 / First Commit Hackathon, I built FrameGuard β an AI-powered continuity assistant that compares two filmed takes and generates a structured report of potentially important visual differences.
ο»Ώ
What Is FrameGuard?
FrameGuard allows a filmmaker to:
- Create a project.
- Create a scene.
- Upload two takes or reference frames.
- Compare the images using AI.
- Identify potential continuity differences.
- Review the findings in a structured report.
The goal isn't to replace a professional script supervisor.
Instead, FrameGuard acts as an AI-assisted second pair of eyes that can help production teams spot details worth checking.
ο»Ώ
Architecture
FrameGuard uses a serverless-oriented architecture with AWS handling storage and application data.
ββββββββββββββββββββββββ β Next.js Frontend β β on Vercel β ββββββββββββ¬ββββββββββββ β β API requests βΌ ββββββββββββββββββββββββ β Next.js Server API β βββββββββ¬βββββββββ¬ββββββ β β Upload β β Data βΌ βΌ ββββββββββββββ ββββββββββββββββ β Amazon S3 β β DynamoDB β β β β β β Take A β β Projects β β Take B β β Scenes β β Images β β Analyses β βββββββ¬βββββββ ββββββββββββββββ β βΌ βββββββββββββββββ β Vision / AI β β Analysis β βββββββββ¬ββββββββ β βΌ βββββββββββββββββ β Continuity β β Report β βββββββββββββββββο»Ώ
The architecture keeps image storage separate from application data and allows the application to use managed AWS services instead of maintaining database or storage servers.
ο»Ώ
Building FrameGuard
1. Amazon S3 for Film Frames
Film images can be large, so FrameGuard uses Amazon S3 for object storage.
Instead of storing uploaded images inside the application's database, FrameGuard stores them as S3 objects and keeps their references in DynamoDB.
For uploads, the application can generate temporary pre-signed URLs:
import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';import { getSignedUrl } from '@aws-sdk/s3-request-presigner';ο»Ώ
const s3Client = new S3Client({ region: process.env.AWS_REGION,});ο»Ώ
export async function createPresignedUploadUrl( key: string, contentType: string) { const command = new PutObjectCommand({ Bucket: process.env.AWS_S3_BUCKET_NAME, Key: key, ContentType: contentType, });ο»Ώ
return await getSignedUrl(s3Client, command, { expiresIn: 900, });}ο»Ώ
The browser can then upload the image directly to S3 using the temporary signed URL.
This keeps the application's API layer from having to handle the complete image payload itself.
ο»Ώ
2. Amazon DynamoDB for Production Data
FrameGuard uses Amazon DynamoDB to store structured application data.
The prototype uses three tables:
Β FrameGuard_ProjectsΒ
Stores production projects.
Example fields:
projectIdnamecreatedAtο»Ώ
Β FrameGuard_ScenesΒ
Stores scenes belonging to a project.
Example fields:
sceneIdprojectIdsceneNumbernamedescriptioncreatedAtο»Ώ
Β FrameGuard_AnalysesΒ
Stores the results of continuity comparisons.
Example fields:
analysisIdprojectIdsceneIdtakeAUrltakeBUrlstatusoverallRiskissueCountissuescreatedAtο»Ώ
The tables use on-demand capacity, which keeps the database configuration simple for the hackathon prototype.
ο»Ώ
3. AI-Powered Continuity Analysis
The core feature of FrameGuard is the visual comparison between two takes.
When the user clicks:
Analyze Continuity
the application sends the selected images to the vision-analysis component.
The AI is instructed to focus on meaningful continuity differences such as:
- π Wardrobe
- β Accessories
- β Props
- π Object positions
- π Major background/environment changes
The system is also instructed to avoid treating insignificant differences such as compression artifacts or minor pixel-level variations as continuity problems.
The goal is to produce structured information rather than an unstructured paragraph.
For example:
{ "summary": "Three potential continuity differences were detected.", "overallRisk": "high", "issueCount": 3, "issues": [ { "category": "wardrobe", "severity": "high", "title": "Shirt appearance changed", "description": "The subject appears to be wearing a different shirt in Take B.", "recommendation": "Verify the wardrobe against the approved continuity reference." }, { "category": "accessory", "severity": "medium", "title": "Watch position changed", "description": "The watch appears on different wrists between the two takes.", "recommendation": "Check the actor's wrist placement before continuing." } ]}ο»Ώ
This structured result can then be saved to DynamoDB and displayed in the application.
ο»Ώ
4. Designing the Continuity Test
For the hackathon demonstration, I created a controlled test scene with deliberate differences.
Take A
- Dark shirt
- Watch on the left wrist
- Coffee cup on the table
- Red notebook positioned beside the cup
Take B
- Different shirt
- Watch on the right wrist
- Coffee cup removed
- Notebook moved to another position
The purpose of this test is to give the AI clearly identifiable continuity changes and make the output easy to verify visually.
FrameGuard presents the result as individual issue cards rather than forcing the user to interpret a long AI response.
ο»Ώ
5. The User Experience
The application follows a simple production workflow.
Dashboard
The filmmaker can see existing projects.
Project
The user can create and manage scenes.
Scene
The filmmaker uploads:
Take A + Take B
Analysis
The user selects:
Analyze Continuity
Results
FrameGuard displays:
- Side-by-side frames
- Overall risk
- Number of detected issues
- Issue category
- Severity
- Description
- Recommended action
This keeps the workflow focused on one question:
βWhat changed between these two takes?β
ο»Ώ
Why AWS?
AWS provides several managed services that fit naturally into this workflow.
Amazon S3
Used for storing uploaded film frames.
Amazon DynamoDB
Used for projects, scenes, and analysis results.
AWS serverless infrastructure
Allows the application backend to use managed services without maintaining traditional servers.
This architecture is particularly useful for a prototype because the project can start small while keeping individual components separated.
ο»Ώ
Security Considerations
FrameGuard is designed so that AWS credentials and secrets are not exposed to the browser.
Environment variables are used for server-side configuration:
AWS_REGIONAWS_ACCESS_KEY_IDAWS_SECRET_ACCESS_KEYAWS_S3_BUCKET_NAMEο»Ώ
For local development, credentials are stored outside the source code and excluded from Git repositories.
For a production deployment, the application should use AWS IAM roles and short-lived credentials instead of embedding long-lived access keys.
S3 objects are also kept private rather than making the entire bucket publicly accessible.
ο»Ώ
What I Learned
1. Architecture should follow the problem
The project started with a filmmaking problem rather than an AWS service checklist.
Once the workflow was defined, S3 and DynamoDB naturally fit the storage and persistence requirements.
2. Structured AI output makes AI applications easier to use
A general AI response can be difficult to interpret consistently.
Returning structured fields such as:
categoryseveritydescriptionrecommendationconfidenceο»Ώ
makes it much easier for the frontend to turn the analysis into a useful interface.
3. Serverless services reduce infrastructure overhead
For this prototype, I didn't need to maintain a traditional database server or dedicated storage server.
Managed AWS services allowed me to focus more on the product workflow and less on infrastructure management.
4. A focused MVP is better than an oversized prototype
Instead of trying to build an entire filmmaking platform, I focused on one core workflow:
Upload two takes βCompare βDetect differences βGenerate report βReviewο»Ώ
That made it possible to demonstrate a complete end-to-end idea within the hackathon timeframe.
ο»Ώ
What's Next?
FrameGuard could eventually be extended with:
- π¬ Screenplay-aware continuity checking
- πΈ Automatic reference-frame selection
- π More detailed wardrobe tracking
- π Character-specific continuity profiles
- π₯ Video-based continuity analysis
- π Script supervisor notes
- π Production continuity history
- π₯ Collaboration between production departments
These features would build on the same core concept while expanding FrameGuard from a two-frame comparison tool into a broader production assistant.
ο»Ώ
The Vision
The idea behind FrameGuard is simple:
Continuity mistakes should be caught while they're still easy to fix.
AI can assist filmmakers by comparing visual references, identifying potentially important changes, and presenting those findings in a format that is easy for a human production team to review.
FrameGuard is an early prototype of that idea, built during the AWS Bharat Builds Tour 2026 / First Commit Hackathon using AWS services and modern web technologies.
ο»Ώ
Try FrameGuard
ο»Ώ
Final Thoughts
Building FrameGuard during the hackathon taught me that the most interesting part of cloud development isn't simply choosing more services.
It's about taking a real-world problem, designing the smallest useful workflow, and using cloud infrastructure to make that workflow practical.
For filmmakers, that workflow is:
Take β Compare β Detect β Review β Fix.
That's the idea behind FrameGuard.
Thanks to AWS and WeMakeDevs for organizing the AWS Bharat Builds Tour 2026 and giving developers an opportunity to build and experiment with real-world ideas.
#BharatBuilds #AWS #Serverless #AI #Nextjs #DynamoDB #S3
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article