After Image

Afterimage uses AI to analyze hours of surveillance footage and find the moments that matter, helping reviewers save time and quickly focus on important events.

Comment 1

Inspiration

Imagine that something serious happens at a business, a public building, or another location with security cameras. Someone needs to understand what happened. There may be several hours of surveillance footage, multiple camera recordings, and only a small window of time in which the most important details can be found.

The incident itself might have lasted less than a minute. Finding that minute, however, could take hours.

That is the problem that inspired Afterimage.

I started thinking about how much important information is stored in surveillance footage and how difficult it can be to access that information when it matters most. Security cameras are installed to help protect people, document incidents, and provide information when something goes wrong. But having cameras does not automatically mean that the relevant footage will be found quickly.

I came across a particularly interesting example involving Jocelyn Pilling and Whole Foods Market. In a 2023 California court ruling concerning an incident at a store in 2021, the court discussed how relevant surveillance footage had become unavailable. The footage from the camera closest to the incident had been saved, but other footage was automatically overwritten through the normal operation of the surveillance system. Another camera recording that was produced was obstructed by a sign. The court did not find that the footage had been intentionally destroyed. What stood out to me was how important the missing footage could have been in understanding exactly what happened.

That case made me think about a larger problem. What if the footage exists, but nobody can find the relevant moments quickly enough? What if the recording contains information that could help someone understand an emergency, investigate an incident, or protect another person, but accessing it requires someone to spend hours manually searching through it?

I did not want to build another application that simply summarizes videos or generates entertainment clips. I wanted to work on a problem where technology could have a more meaningful purpose.

The more I researched the subject, the more I realized that this was not just an inconvenience. It was a documented challenge in security operations and investigations.

The Scientific Working Group on Digital Evidence emphasizes that video evidence can be perishable because surveillance systems have different retention periods and recordings may be overwritten. The College of Policing also discusses the time and effort involved in retrieving, reviewing, and prioritizing CCTV footage. These resources helped me understand that finding relevant footage is not simply about convenience. It is also about time, preservation, and the ability to respond to an incident with useful information.

Research from the Australian Institute of Criminology found that investigators place significant value on CCTV footage, with nine in ten interviewed investigators reporting that they used it when available. Research published in the European Journal on Criminal Policy and Research also examined more than 250,000 recorded crimes to investigate the value of CCTV as an investigative tool.

At the same time, researchers have documented the difficulty of reviewing large quantities of video. A study from the University of Portsmouth examined the cognitive demands of CCTV review, including distractions, the length of the task, image quality, and the possibility of human error. Another study published in the journal Criminology & Criminal Justice discussed the experience of investigators who must review extensive amounts of sensitive video evidence.

These findings helped shape my thinking. The problem was not that surveillance footage was useless. It was that accessing the useful information within it could require an extraordinary amount of time and attention.

I began asking myself a question:

What if someone could upload surveillance footage and have AI help identify the moments that deserve attention first?

That question became Afterimage.

My goal is to help people spend less time searching through recordings and more time understanding what happened. In a serious situation, finding the relevant footage sooner could help people investigate more efficiently and make better-informed decisions. In some circumstances, that additional time could be extremely important.

I know that an application alone cannot guarantee that an incident will be prevented or that someone will be saved. However, I believe there is real value in building technology that helps people access important information when they need it.

I wanted Afterimage to be built around that purpose.

What it does

Afterimage is an AI-powered surveillance video analysis platform designed to help users identify important events within recorded footage without having to manually watch every second.

A user provides a video, and Afterimage analyzes its visual content and available audio to identify potentially significant moments. Instead of returning only a general summary, the platform organizes its findings into individual events with timestamps and explanations.

The idea is to give users a starting point for reviewing a recording. Rather than searching through an entire video from beginning to end, they can first examine the moments the system identifies as potentially relevant.

The current application focuses on several capabilities:

  1. Video analysis

Users can provide a video for analysis. Afterimage processes the recording and uses AI to examine its content. Its purpose is to identify events that may deserve further attention, particularly in surveillance and security-related contexts.

  1. Significant event identification

The system identifies potentially important moments rather than treating the entire recording as one continuous piece of content. Each detected event is presented with contextual information to help users understand why that moment may be worth reviewing.

  1. Timestamp-based navigation

Every identified event is connected to a point in the original recording. This is an important part of the application because identifying an event is only useful if a user can actually find it in the footage.

  1. Audio transcription

Afterimage incorporates OpenAI Whisper to transcribe available audio. This provides another source of context that can contribute to understanding a recording.

  1. Individual clip generation

Users can select an identified event and generate a shorter video clip around it. The purpose is not to create social media content. It is to make relevant portions of a recording easier to review, save, and share with authorized people.

  1. Downloadable results

The application is designed to provide downloadable video clips and associated caption files, making it easier to revisit the selected moments.

Ultimately, Afterimage is intended to make surveillance footage more accessible and useful. Its purpose is to help people locate potentially important information faster, especially when reviewing lengthy recordings is difficult.

The larger vision is to develop a tool that can support security personnel, investigators, organizations, and other authorized users who need to review recorded footage.

How we built it

I built Afterimage as a full-stack web application, bringing together frontend development, backend processing, artificial intelligence, video analysis, and media processing.

The frontend was developed using React, Vite, JavaScript, TypeScript, and Tailwind CSS. I wanted the application to feel like an actual software product rather than a basic demonstration of an AI model. The interface needed to make the analysis understandable and allow users to move between identified events and their corresponding footage.

For the backend, I used Node.js and Express. This handles video uploads, analysis requests, processing tasks, and communication between the frontend and the different services.

One of the most important parts of the application was integrating AI into the video analysis process. I used OpenAI's GPT-4.1-mini for analysis and Whisper for audio transcription. The goal was to combine visual and audio information where available so that the system could produce more useful context about a recording.

We also integrated FFmpeg, which handles the actual video processing. It is responsible for extracting the selected portions of recordings and producing the downloadable clips. This was especially important because I did not want the application to simply tell someone where an event occurred. I wanted users to be able to access that part of the recording directly.

The application uses a separate deployment architecture. The frontend is hosted on Vercel, while the Express backend runs on Render. This allowed me to separate the user interface from the more demanding video-processing operations.

The overall workflow looks like this:

  1. A user submits a video through the application.
  2. The backend receives the video and prepares it for analysis.
  3. The AI services process the available visual and audio information.
  4. The application organizes the results into significant events and timestamps.
  5. The user selects an event for closer review.
  6. FFmpeg processes the corresponding section of the original recording.

The resulting clip and captions are made available to the user.

A major part of building Afterimage was making sure these different components could communicate with one another. The AI analysis, timestamps, original video, and generated clips all need to correspond correctly.

I also had to consider practical limitations. Video processing requires more resources than a typical web application, and large recordings introduce challenges involving upload sizes, processing time, server resources, and storage. I configured upload and processing limits as part of the application rather than assuming that every recording could be processed without restrictions.

The result is a deployed application that brings together multiple technologies to address one specific problem: helping people review surveillance footage more efficiently.

Challenges we ran into

This was easily the most difficult part of building Afterimage. I expected the video analysis and AI integration to take time, but I didn't expect so much of the project to come down to getting the different pieces to communicate with each other. One of my first major problems was getting the OpenAI API to work. I kept receiving a 401 Incorrect API key error, even though I thought I had entered the correct key. What made it especially confusing was that the error message showed a partially masked key ending in different characters than the one in my .env file. I spent time checking where the environment file was located, how the backend was loading it, and whether the local configuration matched the variables on Render. It wasn't simply a matter of pasting in a new key. I had to understand where the application was actually getting its credentials from.

Getting the backend running was another challenge. At one point, I had even deleted parts of it and had to work out how the frontend, Express server, and video-processing code were supposed to fit together again. Once I had the backend running locally, deploying it introduced a different set of problems. The frontend was hosted on Vercel while the backend ran separately on Render, so getting them to communicate meant checking API URLs, environment variables, and deployment settings. There were times when Render showed that the server had started successfully, but a specific request from the website still failed. I also ran into smaller issues that were surprisingly easy to miss, such as generated clip links pointing to the frontend instead of the backend where the actual video files were stored.

The clip-generation feature became its own challenge. I reached a point where Afterimage could identify events, but clicking to generate a clip either produced an empty video or returned a server error. I had to investigate how the timestamps from the analysis were being passed into FFmpeg, whether the clip boundaries were valid, and whether the resulting file was actually being saved and served correctly. Even after fixing the links, the generation request continued returning a 500 error. I'm still investigating that issue by checking whether the request reaches the correct backend route and what happens after it arrives. This was also where the cost of testing became a real concern. Every time I repeated a full AI analysis, I used more of my limited API credits, even when the problem I was trying to solve was actually in the backend or video-processing code. I had to become more careful about separating problems that required another AI analysis from problems I could test using an existing result.

What made these challenges difficult was that fixing one part didn't necessarily mean the application worked as a whole. The AI could identify an event, but the backend might fail to generate its clip; the clip could be created, but the frontend might not be able to find it. I learned to stop treating errors as isolated problems and start tracing what was happening across the entire application. Afterimage has taught me a lot about debugging, deployment, and how much work goes into making something usable beyond my own computer. Getting a feature to work once is one thing. Getting it to work reliably for someone else is a completely different challenge.

Accomplishments that we're proud of

One of the accomplishments I am most proud of is taking an idea based on a real problem and turning it into an actual, deployed application. I didn't want Afterimage to be another project that looked impressive in a demo but didn't do anything beyond displaying a polished interface. I wanted to build something that could take a video, analyze its contents, identify potentially significant events, and connect those events to the original recording. Getting all of those pieces into one application has been a major accomplishment in itself. I brought together a React frontend, a Node.js backend, OpenAI's models for analysis and transcription, and FFmpeg for video processing, while also learning how to deploy and connect separate services through Vercel and Render.

I am particularly proud of the event-to-clip workflow because it represents the main idea behind Afterimage. Identifying an event in a recording is only useful if someone can actually get to that moment. The application is designed to connect an AI-identified event with its timestamp and use that information to generate a shorter clip for review. Getting this workflow together required me to think beyond the AI response and consider what needed to happen afterward, from passing timestamps through the backend to making the resulting video accessible through the frontend. There are still parts of this process I am working to make more reliable, but building the foundation for it has been one of the most rewarding parts of the project.

More than anything, I am proud that Afterimage has a purpose beyond demonstrating what AI can do. I started with a problem involving real recordings and the difficulty of finding the moments that matter. That gave me a reason to keep building even when the technical side became frustrating. There were plenty of points where I could have left the project as a concept or a basic interface, but I kept working through problems because I wanted to see how far I could take the idea. Having a deployed application that brings these technologies together, even while I continue improving it, is something I am genuinely proud of.

What we learned

Building Afterimage changed how I think about developing AI applications. Before working on it, it was easy to think of the AI model as the central part of the product: send it information, receive an answer, and display the result. In practice, the model is only one part of a much larger system. The backend has to receive and process the video, the transcription needs to correspond to the correct recording, the analysis needs to return useful timestamps, and the video-processing tools need to turn those timestamps into clips that actually work. I learned this through trial and error. An analysis could finish successfully while the clip-generation request failed, or a clip could be created while the frontend struggled to locate the file. Each problem forced me to look at how the different parts of the application depended on one another rather than treating every feature as something separate.

I also learned that using AI in a security-related application requires a different level of care. An AI model can miss an event, misunderstand what it is seeing, or describe something without having enough context to understand its significance. Something that appears unusual is not automatically evidence of wrongdoing, and an event the model overlooks could still matter to the person reviewing the footage. That is why I see Afterimage as an assistance tool rather than a system that determines what happened. Its purpose is to help bring potentially relevant moments to someone's attention, while leaving the original recording available for a person to examine and verify. Research into digital evidence and video surveillance also made me think more carefully about what happens to recordings after they are uploaded, who should be able to access them, and how they should be stored and preserved. I don't want efficiency to come at the expense of privacy or the integrity of the footage.

Perhaps the biggest lesson was understanding the difference between getting something to work once and building something another person can actually rely on. Developing Afterimage involved learning unfamiliar tools, connecting services I had never deployed together before, and spending hours investigating errors that sometimes turned out to be caused by a single configuration or connection issue. It also taught me to be more careful about testing. Repeating a full AI analysis just to investigate a backend problem used API credits without necessarily bringing me closer to finding the cause. I gradually learned to isolate problems and test the specific part of the application that was failing. That mindset has probably been one of the most valuable things I have taken away from the project.

What's next for After Image

The current version of Afterimage is a foundation, and there is still a lot I want to improve before considering it suitable for real-world security operations. My first priority is making the existing workflow more reliable, particularly the connection between event detection, timestamps, and clip generation. If the application identifies an event at a certain point in a recording, the resulting clip needs to contain the correct moment and enough surrounding context for someone to understand what happened. I also want to improve how the application analyzes surveillance footage, where important details may be brief, subtle, or difficult to understand without looking at what happened before and after. The goal isn't to generate more descriptions just for the sake of it. I want the results to help someone find the footage they are actually looking for.

Once the core workflow is more dependable, I want to explore supporting longer recordings and more complex review processes. One direction I find particularly interesting is organizing multiple recordings around the same incident. For example, an event at a public building might appear in footage from several different cameras. Being able to organize those recordings and help a reviewer locate the relevant sections could make the process much more useful than analyzing each video independently. This is not something the current version supports yet, but it is a direction I would like to investigate as the project develops.

The larger goal is to make Afterimage useful in situations where finding information quickly can matter. Consider an incident at a public building where someone needs to review hours of security footage to understand what happened. They may need to establish when the event occurred, find the relevant recording, and examine the moments surrounding it. Instead of starting by manually searching through every minute, an AI-assisted tool could help point them toward sections worth reviewing. I don't expect AI to determine what happened or replace the people responsible for investigating an incident. I want it to make the initial review process less time-consuming so those people can spend more time examining the information that matters.

As the application develops, privacy and accountability will need to be part of the product itself, not something added at the end. Surveillance recordings can contain sensitive information, so any real-world implementation would need secure file handling, appropriate access controls, clear retention policies, and safeguards against unauthorized use. I also want to keep the focus on reviewing specific recordings for legitimate purposes, rather than building features around identifying or tracking individuals. Any AI-generated result should remain something a person can question and verify against the original footage.

Ultimately, I want Afterimage to make reviewing surveillance footage less about searching through hours of recordings and more about getting to the moments that deserve attention. I started this project because I saw a problem that I thought technology could help address, and I want to keep developing it into something that has a practical purpose outside of a hackathon or a demonstration. There is still a lot to prove, especially when it comes to reliability, but that is what makes the next stage of the project exciting to me.

Afterimage is built around one idea: when something important happens, finding the moment should not be the hardest part.

Built With

Share this project:

Updates

posted an update —

Afterimage connects art and technology by using AI to transform raw video footage into meaningful, organized visual stories. It demonstrates how technology can enhance the way we capture, interpret, and interact with visual media, turning hours of footage into accessible insights.

Submission history