AWS Builder Center
Full Stack Challenge: EchoMark

Full Stack Challenge: EchoMark

A guest-mode eco-action tracker where every logged habit ripples across a shared community pond built serverless on AWS after a mid-challenge pivot from Amplify CLI to a fully manual Console build.

Cloud Architect
Ripple Live App:  https://echomark-app-abdulhayee.s3.us-east-1.amazonaws.com/index.html  Author: Abdul hayee -- Cloud/DevSecOps Engineer
Vision and What It Does
Every small sustainable choice using a reusable cup, taking a cold shower, skipping a purchase for a day feels invisible in isolation. You do it, and nothing seems to happen. EchoMark is built on a simple belief: those small actions aren't invisible, they're just unmeasured. The app gives people a place to log everyday eco-actions and instantly see that choice rendered as an animated ripple spreading across a shared "pond" a visual, communal record of collective impact.
The target user isn't someone trying to track carbon footprints with scientific precision. It's anyone who wants a lightweight, satisfying way to notice their own habits and feel, even briefly, that they're part of something bigger than a single household. Log an action, watch a ripple bloom, see other guests' ripples already sitting there. No sign-up, no friction — just tap and watch it spread.
Full Stack Breakdown
This build followed the pitch-to-launch arc from The Full Stack series directly:
Pitch: The idea started as a three-feature concept (ripple logging, streak "biomes," friend challenges) inspired by the word Ripple. I deliberately cut it down before writing a line of code — the community pond alone was strong enough to carry the demo, and trying to ship all three in 48 hours would have meant shipping none of them well.
Prototype: I wrote a full SRS before touching AWS, splitting features into a strict MVP tier and an explicitly out-of-scope tier (auth, friend chains, real-time sockets, carbon-accuracy scoring). That document became the single source of truth for every build decision that followed.
MVP: Guest-mode identity (no Cognito), a DynamoDB table, two Lambda functions, and a static frontend — the smallest set of moving parts that could still deliver the "wow" moment: log an action, see it ripple, see everyone else's ripples too.
UX: A splash screen with tap-or-swipe entry, five one-tap eco-actions, persistent ripple visuals (not just a flash-and-fade animation) so the pond visibly fills up over a session, and a dark/light theme toggle.
Launch: Deployed entirely through the AWS Console and live on S3 static website hosting.
How I Built It
The plan was to use the Amplify CLI for a fast, scripted build but Amplify Gen 1 CLI is now closed to new AWS accounts ("has entered maintenance mode and will no longer accept new customers"), which surfaced immediately on amplify init. Rather than lose hours migrating to Gen 2's unfamiliar workflow mid-challenge, I pivoted to building every resource manually through the AWS Console: DynamoDB table, IAM role, two Lambda functions, and a REST API in API Gateway.
That pivot surfaced two real bugs worth noting for anyone doing the same: ScanIndexForward has no effect on a DynamoDB Scan operation (it only works on Query), so "latest first" ordering had to be handled with a manual JavaScript sort after the scan. And API Gateway needs Lambda proxy integration explicitly enabled — without it, the raw Lambda response object (statusCode, headers, body as a JSON string) gets returned as-is instead of being unwrapped into a clean response.
A third issue only appeared after deploying the frontend to S3: crypto.randomUUID() requires a secure context (HTTPS), and S3 static website hosting serves over plain HTTP. Guest ID generation silently failed and broke the rest of the script. The fix was a manual UUID fallback that works regardless of context security.
AWS Services / Architecture
Browser (S3 static website, HTTP) → localStorage guestId (client-generated, no auth) → API Gateway (REST API, CORS enabled) → Lambda: echoMarkLog (POST /log) → DynamoDB PutCommand → Lambda: echoMarkPond (GET /pond) → DynamoDB Scan + sort → DynamoDB table: guestId (PK) + timestamp (SK)
Amazon S3 — static website hosting for the frontend
Amazon API Gateway — REST API with two resources (/log, /pond), Lambda proxy integration, CORS
AWS Lambda (Node.js, AWS SDK v3) — two functions handling write and read paths
Amazon DynamoDB — single table storing every guest's logged actions
IAM -- a scoped role granting the Lambdas read/write access to the table
No Cognito, no AppSync, no real-time infrastructure — every one of those was deliberately scoped out to protect the 48-hour deadline, and the app didn't lose its core "community" feel by skipping them: any guest's action is visible to every other guest via a simple DynamoDB scan.
What I Learned
The biggest lesson wasn't a specific AWS service it was how fast scope creep kills a hackathon build. Every added feature (auth, real-time sync, biome animations) sounded reasonable in isolation but each one threatened the one feature that actually mattered for the demo: the pond filling up in front of you. Writing the SRS first, with an explicit "out of scope" tier, made every later trade-off a five-second decision instead of a debate.
Technically, I got real hands-on practice with DynamoDB's Scan-vs-Query distinction, API Gateway's proxy integration model, and the quiet ways browser security contexts (HTTP vs HTTPS) can break client-side code that works perfectly in a code editor. I also learned, the hard way, that CLI tooling isn't guaranteed to be available for new accounts — building comfort with the raw AWS Console as a fallback turned out to be as valuable as the app itself.
Link to App
Built for the AWS Full Stack Challenge — one ripple at a time. 🌊
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