AWS Builder Center
Weekend Showcase Challenge: EchoClass

Weekend Showcase Challenge: EchoClass

EchoClass turns recorded lessons into interactive learning timelines, letting students capture and revisit the moments that matter.

💡 The Spark

Imagine watching a recorded lecture. It’s 31 minutes and 14 seconds in. The professor explains a complex formula, and suddenly you hit a wall: "Wait, why did the variable change here?" In standard online learning, that moment is lost. You either write a quick note on a separate piece of paper, open another app, or simply give up and keep watching. Recorded education has always been passive—students watch, forget, and struggle to locate key moments later.
Over the summer, I wanted to explore a simple question:
What if a recorded lesson could remember the moments that mattered to students?
That question became EchoClass, a collaborative classroom replay platform built around one simple idea: every lesson leaves a trace.
Most recorded classes are passive. A student watches a video, takes some notes, and eventually moves on. But during that video, there are usually moments that stand out:
"I don't understand this."
"This is important."
"This finally clicked."
I wanted to build a system where students could capture those moments directly inside the lesson.
That became the idea behind an Echo.
An Echo is a timestamped reaction that a student can leave while watching a lesson. It can represent confusion, importance, or insight, with an optional personal note.
Instead of the video simply ending when the student reaches the end, the lesson gradually builds a learning timeline around it.

🎓 The Vision

The goal of EchoClass is not to build another full Learning Management System.
I wanted to focus on one specific part of learning that I felt was missing from recorded education:
the connection between a lesson and the moments where students actually learn.
Imagine watching a recorded lecture and reaching  31:14 .
Something in the explanation doesn't make sense.
Instead of opening another application or writing down the timestamp somewhere, you can simply leave a Confused Echo at that exact moment.
Later, you can return to it.
Or perhaps the teacher explains an important concept. You mark it as Important.
Or suddenly everything makes sense. You leave an Insight.
These moments become part of the lesson's timeline.
The basic learning loop is:
Watch → React → Leave an Echo → Return → Understand
That is the experience I wanted EchoClass to explore.

🔊 What is an Echo?

EchoClass currently supports three primary Echo types:
  • 😕 Confused — "I don't understand this."
  • ⭐ Important — "I want to remember this."
  • 💡 Insight — "This finally clicked."
Each Echo is associated with the exact playback timestamp of the lesson.
For example:
Lesson: Introduction to Algorithms
Timestamp: 31:14
Echo: Confused
Note: "Why does the complexity change here?"

The important part is that the timestamp isn't just text.
It is structured data connected to the actual lesson.
That means the student can later jump directly back to that moment in the video.
Over time, these individual reactions can become a timeline of activity around the lesson, creating the foundation for identifying moments where students interacted heavily with the material.

🧠 How EchoClass Works

I designed EchoClass around two different roles: teachers and students.
Teachers can create private classes, share an invite code with students, create recorded lessons, upload lesson videos, and publish those lessons.
Students can join classes using the invite code, access published lessons, watch the videos, and create their own Echoes.
The core flow looks like this:

The interesting part is what happens between the video player and the backend.
When a student creates an Echo, EchoClass captures the current playback position from the HTML5 video player.
That timestamp is sent to the backend along with the Echo type and optional note.
The backend then validates the request, verifies that the student is actually allowed to access the lesson, and persists the Echo.
This turned what initially sounded like a simple UI interaction into a complete end-to-end cloud workflow.

☁️ AWS Architecture

EchoClass is built as a serverless AWS application.
The main AWS services I used are:
  • Amazon Cognito — handles user authentication and identity.
  • Amazon API Gateway — exposes the application's HTTP API.
  • AWS Lambda — handles backend application logic and authorization.
  • Amazon DynamoDB — stores users, classes, memberships, lessons, and Echoes.
  • Amazon S3 — stores lesson video files privately.
  • Amazon CloudFront — delivers private lesson media to students.
  • AWS CDK — defines and provisions the infrastructure.
  • Amazon CloudWatch — provides backend logging and debugging visibility.
The high-level architecture looks like this:

One of the architectural decisions I cared about most was keeping the lesson videos private.
I didn't want students to receive unrestricted public S3 URLs.
Instead, lesson media is stored in a private S3 bucket and delivered through CloudFront. The application verifies access before providing the playback path, while CloudFront handles the actual media delivery.
This also means Lambda isn't responsible for streaming large video files. The application logic stays focused on authorization and data, while S3 and CloudFront handle the media.

🛠️ How I Built It

I started with the product idea and gradually turned it into a working vertical slice.
The first pieces were the basic application structure, authentication, user roles, classes, and class membership.
From there, I moved into lessons.
Teachers needed to be able to create lessons and upload actual video files, while students needed to see only the lessons they were authorized to access.
That introduced the first important AWS architectural decision: the browser should upload large media directly to S3 rather than sending the entire video through Lambda.
I implemented multipart video uploads with the backend generating the required authorization and the browser transferring the actual file to S3.
Once the lesson system was working, I focused on the Echo MVP.
The Echo composer had to communicate with the video player, capture the current timestamp, send it to the API, validate it on the backend, and persist it in DynamoDB.
Then came the other side of the loop: reading those Echoes back and connecting them to the lesson timeline and video playback.
This is where EchoClass started feeling like the product I originally imagined rather than just a collection of AWS services.

🔐 Security and Authorization

One thing I learned very quickly while building EchoClass is that authentication and authorization are two different problems.
Amazon Cognito answers:
"Who is this user?"
But EchoClass still needs to answer:
"What is this user allowed to access?"
That responsibility lives in the backend.
For example, a student shouldn't be able to access a lesson simply because they know its ID.
The backend verifies their authenticated identity, checks their class membership, and verifies that the lesson is actually published.
The same principle applies to Echoes.
A student can create and modify their own Echoes, but they cannot simply change an ID in the request and modify another student's Echo.
Keeping those authorization rules server-side became an important design principle throughout the project.

🔧 The Challenges

The most interesting part of this project was honestly the debugging.
Getting a basic React interface running was relatively straightforward.
Getting the entire system to work reliably across Cognito, API Gateway, Lambda, DynamoDB, S3, and CloudFront was a very different problem.
I ran into issues with API routes, CORS, DynamoDB persistence, request and response shapes, timestamp validation, video uploads, and playback behavior.
There were also cases where the frontend appeared to be doing the right thing while something deeper in the backend was failing.
That forced me to get much more comfortable with CloudWatch logs and tracing requests across multiple AWS services.
One particularly useful lesson was that a successful frontend request doesn't necessarily mean the feature is actually working.
For example:
Browser → API → Lambda → DynamoDB
is one feature from the user's perspective, but it is several separate systems that can fail independently.
I had to learn to debug the entire path rather than just looking at the browser.
I also spent time making video playback more reliable and ensuring that navigating away from the browser tab didn't unexpectedly destroy the player's state.
These problems were frustrating while I was building them, but they ended up teaching me much more than simply following a tutorial would have.

🌱 What I Learned Across the Summer

The biggest thing I learned throughout the Summer Build Series is that building a real application on AWS is less about individual services and more about how those services work together.
At the beginning, services like Cognito, Lambda, DynamoDB, S3, API Gateway, and CloudFront can look like separate building blocks.
As the project grew, I started seeing them as parts of one system.
Cognito handles identity.
Lambda handles application logic.
DynamoDB handles persistence.
S3 handles large media objects.
CloudFront handles media delivery.
And the frontend ties the experience together.
I also learned a lot about designing APIs around real authorization rules rather than simply making endpoints that return data.
Another major lesson was around infrastructure.
Using AWS CDK meant that the infrastructure itself became part of the project rather than something I had manually configured once and hoped I would remember later.
Most importantly, I learned to build vertically.
Instead of trying to implement every feature at once, I found it much more useful to take one complete flow and make it work from beginning to end.
For EchoClass, that eventually became:
Authenticate → Join Class → Open Lesson → Play Video → Create Echo → Persist Echo → Return to Echo
Once that loop worked, the rest of the product became much easier to reason about.

🚀 What's Next?

EchoClass is still an evolving project.
The current implementation focuses on establishing the core learning loop and the infrastructure required to support it reliably.
The next step is to take the web application itself fully into its public deployment architecture, with the React application served through CloudFront alongside the private lesson media delivery.
Beyond that, I want to explore the bigger potential of the Echo Timeline.
The long-term question is:
What can we learn from the collection of moments students leave behind?
If many students interact around the same part of a lesson, that could become a useful signal for a teacher.
A teacher might discover that a particular explanation consistently generates confusion, or that a specific section is especially important to students.
The important part is that these signals can be generated from actual student interaction rather than trying to guess what students understood.
I also want to keep the original privacy principle intact.
EchoClass isn't intended to turn learning difficulties into a public scoreboard. Individual student notes should remain personal, while useful classroom-level signals can be aggregated.
That balance between useful learning analytics and student privacy is something I want to explore further.

🔗 Project

AWS: Deployed using AWS services including Amazon Cognito, API Gateway, Lambda, DynamoDB, S3, CloudFront, CloudWatch, and AWS CDK.
If you try EchoClass, I'd love to hear what you think about the idea of leaving an Echo on a lesson.
Is there a different type of Echo you would want to leave?
Or what would make you want to come back to a lesson after you've already watched it?

🙌 Inspiration

I'd like to thank @umar12 for inspiring me during the Summer Build Series, along with everyone in the AWS Builder community who shared their projects, experiments, and ideas throughout the summer.
#application
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