AWS Builder Center
Full Stack Challenge: CircleUp

Full Stack Challenge: CircleUp

CircleUp is a hyper-local community platform inspired by the challenge word “Ripple.” It helps neighbors share requests, offer skills, and connect through small acts of help, while visualizing how those interactions create a ripple of positive community connections.

Cloud, Data | AWS Student Builder Group Leader

Full Stack Challenge: CircleUp

Turning Small Acts of Help Into Community Ripples

Every community has people willing to help. Someone carries groceries for a neighbor, lends a tool, shares a skill, watches a pet, or helps someone move.
These interactions may seem small, but they can create a chain reaction.
For The Full Stack Challenge, my random word was:
Ripple
That word became the foundation for CircleUp, a hyper-local community platform where small acts of help can create visible connections between people.
The core idea is simple:
One small act → one connection → one ripple → a stronger community. 🌊



🎯 What is CircleUp?

CircleUp is designed around a simple question:
What if we could see how one small act of help inspires another?
Instead of building another social network around likes and followers, CircleUp focuses on local interactions.
Users can:
  • Ask their community for help
  • Offer help to others
  • Share skills
  • Respond to local requests
  • Build connections through completed interactions
  • Visualize those connections through a Ripple Map
  • Track their contribution through ripple activity
The goal is to make invisible acts of kindness visible.



🌊 The Ripple Concept

Imagine this interaction:
Aryan
│
│ helps
▼
Priya
│
│ pays it forward
▼
Rahul
│
│ helps
▼
Neha
One interaction becomes another.
CircleUp represents these relationships as a growing social graph.
This became the central product experience rather than treating “Ripple” as just a visual theme.



✨ Core Features

1. Circle Board

The Circle Board is where community interactions begin.
A user can create a post such as:
🛠️ “I need help moving a small table.”
Another user can respond:
🤝 “I can help!”
Once the interaction is completed, CircleUp records the connection.



2. Ripple Map

The Ripple Map is the centerpiece of CircleUp.
Instead of simply showing a list of completed interactions, it visualizes how help moves from person to person.
Example:
┌─────────┐
│ Aryan │
└────┬────┘
│
helps
│
▼
┌─────────┐
│ Priya │
└────┬────┘
│
pays it forward
│
▼
┌─────────┐
│ Rahul │
└────┬────┘
│
helps
│
▼
┌─────────┐
│ Neha │
└─────────┘
The objective isn't to create a leaderboard.
It's to show the impact of participation.



🏗️ AWS Architecture

CircleUp uses AWS services across the frontend, authentication, API, database, serverless processing, and scheduled activity.
┌──────────────────────┐
│ CircleUp │
│ Web Client │
└──────────┬───────────┘
│
▼
┌──────────────────────┐
│ AWS Amplify │
│ Hosting / Deployment │
└──────────┬───────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌────────────────┐ ┌────────────────┐
│ Amazon Cognito │ │ AWS AppSync │
│ Authentication │ │ API / Data │
└────────────────┘ └───────┬────────┘
│
▼
┌──────────────────┐
│ DynamoDB │
│ │
│ Users │
│ Posts │
│ Connections │
│ Ripple Data │
└────────┬─────────┘
│
▼
┌──────────────────┐
│ AWS Lambda │
│ Ripple Processing │
└────────┬─────────┘
│
▼
┌──────────────────┐
│ Amazon EventBridge│
│ Scheduled Jobs │
└──────────────────┘
The architecture is intentionally serverless, allowing the application to scale without maintaining traditional servers.



🔐 Authentication

CircleUp uses Amazon Cognito for user authentication.
The high-level flow is:
User
│
│ Sign Up / Sign In
▼
Amazon Cognito
│
│ Authenticated session
▼
CircleUp Application
│
▼
Authorized API requests
Authentication keeps community interactions associated with verified application users while allowing the backend to control access to protected operations.



🗄️ Data Model

The core application entities are users, posts, and ripple connections.
A simplified representation looks like:
User
├── id
├── name
├── neighborhood
├── rippleScore
└── createdAt

Post
├── id
├── authorId
├── title
├── description
├── type
├── status
└── createdAt

Ripple
├── id
├── fromUserId
├── toUserId
├── postId
├── action
└── createdAt
This structure allows CircleUp to represent both the original community activity and the relationships created from it.



⚡ Creating a Ripple

When a user responds to a request and the interaction is completed, the application creates a ripple relationship.
A simplified example of the backend logic is:
async function createRipple({
fromUserId,
toUserId,
postId
}) {
const ripple = {
id: crypto.randomUUID(),
fromUserId,
toUserId,
postId,
action: "HELPED",
createdAt: new Date().toISOString()
};

await saveRipple(ripple);

await updateRippleScore(fromUserId);

return ripple;
}
The important part isn't the number of lines of code.
It's the relationship represented by the data:
Person A
│
│ helped
▼
Person B
That relationship can then become part of the Ripple Map.



🔄 Ripple Map Data Flow

When a ripple is created:
User completes interaction
│
▼
API request
│
▼
AppSync
│
▼
Lambda
│
▼
DynamoDB
│
▼
Ripple relationship
│
▼
Ripple Map
│
▼
UI updates
This creates a direct connection between an actual community interaction and its visualization in the application.



📊 Karma Pulse

CircleUp also includes a community activity concept called Karma Pulse.
Instead of measuring likes or followers, the application looks at community activity such as:
  • New requests
  • Help offered
  • Completed interactions
  • New ripple connections
A scheduled process can calculate a neighborhood activity score.
Conceptually:
Community Activity
│
├── Requests
├── Offers
├── Completed Help
└── Ripple Connections
│
▼
Activity Score
│
▼
Karma Pulse
Amazon EventBridge can trigger scheduled processing, with AWS Lambda handling the calculation.



📍 Hyper-Local Community

CircleUp is designed around the idea that community interactions should feel local.
The application can use location-aware functionality to scope community activity around a user's neighborhood rather than presenting an enormous city-wide feed.
The long-term vision is:
User
│
▼
Location
│
▼
Neighborhood
│
├── Requests
├── Offers
└── Skills
This makes CircleUp about your community, rather than the entire internet.



🎨 UX & Dark Mode

I wanted the application to feel different from a typical developer dashboard.
The design direction was inspired by:
A Sunday farmers market — warm, human, simple, and welcoming.
The interface uses soft visual elements, community-focused cards, and an organic visual language around the Ripple concept.
I also implemented dark mode to make the experience comfortable across different environments and to participate in the challenge's dark-mode bonus opportunity.



🧪 Demo Walkthrough

The main demo flow for CircleUp is:

Step 1 — Sign in

A user creates an account and enters their CircleUp community.

Step 2 — Discover the Circle

The user sees nearby community requests and offers.

Step 3 — Create an interaction

For example:
“I need help carrying groceries upstairs.”

Step 4 — Another user responds

A nearby community member offers help.

Step 5 — Complete the interaction

Once the interaction is completed, CircleUp creates a ripple.

Step 6 — Watch the Ripple Map

The new connection appears in the Ripple Map.
Aryan ─────► Priya
│
│
▼
Rahul

Step 7 — See the impact

The user's ripple activity increases and the community's activity data changes.
This demonstrates the complete journey:
Need
↓
Connection
↓
Help
↓
Ripple
↓
Community Impact



🛠️ How I Built It

I started with the challenge word rather than starting with a technology stack.
The first step was translating Ripple into a product concept.
From there, I defined the smallest useful experience:
Idea
↓
User Flow
↓
MVP
↓
AWS Architecture
↓
Implementation
↓
Deployment
↓
Polish
The biggest constraint was time.
With a 48-hour build window, I had to constantly distinguish between:
Must have
and
Nice to have.
Features that directly supported the core ripple experience stayed in the MVP.
Everything else was treated as a future improvement.



🚧 Challenges

One of the biggest challenges was turning an abstract concept into something users could immediately understand.
“Ripple” sounds simple, but it could lead to hundreds of different applications.
The Ripple Map became the answer.
Instead of simply telling users that their actions matter, CircleUp gives them a visual representation of how those actions connect people.
Another challenge was scope.
A neighborhood platform could easily expand into messaging, notifications, events, recommendations, moderation, maps, and many other features.
For this challenge, I prioritized the core experience:
Request → Help → Connection → Ripple



💡 What I Learned

The Full Stack Challenge reinforced something important:
Building a product isn't just about building features.
The strongest technical architecture doesn't matter if the user doesn't understand why the product exists.
I learned to start with the user experience and then work backward toward the technical implementation.
I also gained experience thinking about AWS services as pieces of a complete architecture rather than isolated services.
Authentication, APIs, databases, serverless functions, scheduled processing, and hosting all need to work together to create a coherent product.
Most importantly, the challenge taught me to ship.
A focused application that works is more valuable than an ambitious application that never gets deployed.



🚀 Future Improvements

CircleUp could grow significantly beyond the challenge MVP.
Some potential improvements include:
  • AI-powered matching between people who need help and people who can help
  • Push notifications for nearby requests
  • Community moderation
  • Trust and reputation mechanisms
  • Improved location-based discovery
  • Community events
  • Volunteer opportunities
  • Advanced Ripple Map visualizations
  • Personalized community recommendations
One particularly interesting direction would be using Amazon Bedrock to intelligently match a request with people who have the relevant skills or interests.
For example:
"I need help fixing my bicycle"
│
▼
AI understands need
│
▼
Finds relevant skills
│
▼
Suggests nearby community
│
▼
Ripple



🎬 The Final Demo

The complete CircleUp experience can be summarized in one interaction:
Someone needs help
↓
They post to CircleUp
↓
A neighbor responds
↓
The interaction is completed
↓
A Ripple is created
↓
The Ripple Map grows
↓
Another person is inspired
↓
The cycle continues
That's what I wanted CircleUp to demonstrate.
A community doesn't become stronger because of one huge action.
It becomes stronger because small actions keep spreading.



🌊 Final Thoughts

The word Ripple started as a random challenge prompt.
It became an idea about something much more human: the impact of small actions.
A person helping a neighbor may seem insignificant.
But that interaction can inspire another person, who helps someone else, creating a chain of connections that grows beyond the original action.
That's CircleUp.
Make one small difference. Let it ripple outward. 🌊



🔗 Project Links

Live Application: [ADD YOUR DEPLOYED APP URL]
GitHub Repository: [ADD YOUR GITHUB REPOSITORY URL]
Built by: Aryan Vijaykar
Built for The Full Stack Challenge — AWS
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