AWS Builder Center
Weekend Showcase Challenge: Youtube Video Summary

Weekend Showcase Challenge: Youtube Video Summary

I revisited my serverless video summarization app to simplify deployment for new users, solve a CORS issue, and add an ASCII Content Map. The experience showed me how much I have grown through the AWS Builder challenges this summer.

Entrepreneur & AWS Instructor at VocêCertificado®
For this Weekend Showcase Challenge, I decided to return to a project I had built before: The YouTube Video Summary.
My goal was not simply to deploy the same application again. I wanted to rebuild and improve the project so that other builders could deploy it more easily in their own AWS accounts.
This required reviewing the source code, testing the infrastructure from the beginning, reorganizing the deployment instructions, and removing assumptions that only made sense in my original environment.
I also wanted to take the application one step further by adding a new feature called Content Map. In addition to generating a written summary, the application now creates a visual ASCII map that organizes the central topic, main topics, and their subtopics. This gives users another way to understand the structure of a video before deciding whether to watch it.
In this article, I will share what it was like to return to this challenge, improve the deployment experience, solve an unexpected CORS issue, and extend the application with a new feature.



Vision and what it does

Watching a long YouTube video before knowing whether it contains useful information can consume a lot of time. The idea behind YouTube Video Summary came from movie trailers. A trailer helps someone decide whether a two-hour movie is worth watching. I wanted to create a similar decision shortcut for YouTube videos.
Turn videos into clear summaries

The user provides the URL of a public YouTube video. The application retrieves the available transcript, identifies its language, and generates a structured summary containing a concise overview, key points, a conclusion, and the new Content Map.
Video summary and generated key points

The Content Map uses plain ASCII characters to display the thematic hierarchy of the video. It starts with one central topic and organizes the main topics and relevant subtopics below it. This is especially helpful for technical videos, presentations, and tutorials with several related subjects.
Conclusion and Content Map

The application also displays the detected language and the transcript character count. Its interface is available in English and Brazilian Portuguese.
You can explore the complete source code and deployment instructions in my  GitHub Repository .



How I built it

I started by defining the smallest architecture that could solve the problem without adding unnecessary infrastructure.
The frontend was built with React 19 and Vite 8 and is hosted with AWS Amplify Hosting. It communicates with the backend through an AWS Lambda Function URL.
The backend was developed in Python 3.13 and deployed with AWS SAM. When a request arrives, the Lambda function validates the YouTube URL, retrieves the Supadata API key from AWS Systems Manager Parameter Store, requests the public transcript, identifies its language, and invokes Amazon Nova Micro through Amazon Bedrock.
Amazon Nova Micro generates the structured summary and the ASCII content map through the Amazon Bedrock Converse API. Nova Micro is a text-only model designed for low latency and cost, which makes it a practical choice for this application.
One of my key decisions was to keep the application serverless. The project does not require Amazon EC2, containers, Elastic Load Balancing, Amazon API Gateway, a database, or persistent transcript storage.
I also followed the principle of least privilege. The Lambda execution role can invoke only the selected Amazon Nova Micro model and retrieve only the specific parameter containing the Supadata API key.
To make the project easier for new users to deploy, I revised the entire installation process. The instructions now guide users through creating a fork, deploying the backend with AWS SAM, retrieving the unique Lambda Function URL, configuring it as  VITE_API_URL  in Amplify, obtaining the new Amplify domain, and then updating CORS with that exact origin.



AWS architecture overview

The application uses the following AWS services:
AWS Architecture

  • AWS Amplify Hosting hosts and continuously deploys the React and Vite frontend.
  • AWS Lambda validates requests, processes transcripts, invokes Amazon Bedrock, and returns the result.
  • AWS Lambda Function URL provides the public HTTPS endpoint used by the frontend.
  • Amazon Bedrock provides generative AI inference through the Converse API.
  • Amazon Nova Micro generates the summary and Content Map.
  • AWS Systems Manager Parameter Store stores the Supadata API key as a  SecureString .
  • AWS Identity and Access Management controls the permissions used by the Lambda function and deployment user.
  • AWS CloudFormation and AWS SAM define and deploy the backend infrastructure.
The request flow is straightforward. The user opens the application hosted by Amplify and submits a YouTube URL. The browser sends an HTTPS  POST  request to the Lambda Function URL. Lambda retrieves the transcript through Supadata, sends the content to Amazon Nova Micro, and returns the structured result to the frontend.
The  live application  will remain available until August 31, 2026, at 1:00 PM PT.



Lesson learned

Across this summer, the AWS Builder challenges pushed me to use services I had never used before and to find simple solutions for difficult problems. They encouraged me to move beyond familiar tools, experiment with new architectures, and learn by building.
During this revision, I faced a CORS problem between AWS Amplify and the Lambda Function URL. The application loaded correctly, but the browser blocked requests to the backend.
I identified the problem through Google Chrome Inspector. The browser showed that the preflight request did not receive the required  Access-Control-Allow-Origin  header. After investigating the deployment, I discovered that the Lambda Function URL still allowed an older Amplify domain.
I solved the issue by turning the allowed origin into a CloudFormation parameter. The first backend deployment now uses a temporary invalid origin. After Amplify creates the final domain, the backend is deployed again with the correct origin. AWS Lambda then handles the CORS headers for the Function URL, including the browser’s preflight request.  AWS documents this behavior for Lambda Function URLs .
This experience reminded me that improving a project is not only about adding features. It is also about making the project understandable, reproducible, and easier for someone else to use.
The complete review, deployment tests, adjustments, documentation improvements, troubleshooting, and addition of the Content Map required four hours of development.
Looking back at the original challenge, I can see that I am now a new person and a more deliberate builder. I approach problems differently, investigate errors more carefully, and think beyond whether something works only in my environment.
I would also like to tag  Giarmani , whose  articles about serverless  inspired me. Her content reminds me how serverless architectures can transform simple ideas into practical applications.
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