Donation Platform with Real-Time Impact Tracking
Description
Develop a web-based donation platform that allows users to donate to various
charitable causes, track donation progress in real-time, and visualize the impact of their
contributions. The system should support multiple campaigns and provide insights into
donation patterns.
Key Features
• Multi-Campaign Support: Users can browse and donate to different charity
campaigns (e.g., education, healthcare, disaster relief).
• Real-Time Progress Tracking: Display live updates on donation totals and
campaign goals using a reflexive UI.
• Pattern-Based Validation: Ensure donation amounts are positive decimals and
campaign names are alphabetical with optional spaces.
• Pattern Matching Rules: Identify the top 3 campaigns by donation amount and
flag unusually high donations for admin review.
• Simple Rules: Prevent donations exceeding a user’s daily limit (e.g., $500/day,
configurable).
• Nice-to-Have: Import excel sheet with donation information and load it into the
system or/and support chat based information retrieval.
Instructions
• Time Limit: Candidates have 2 hours to implement the use case.
• Execution: Full implementation is mandatory; designing alone is insufficient.
• Open-Book Challenge: Candidates may use online resources, AI tools, or
documentation.
• Platform Choice: Candidates can choose any tech stack (e.g., React/Django,
Vue/Express, etc.), and it will not impact evaluation.
• Evaluation Criteria: Focus on problem-solving, implementation efficiency, and
creativity.
• Deliverables:
o Frontend: A user-friendly interface to browse campaigns, make
donations, and view real-time progress (e.g., progress bars or charts).
o Backend: APIs to handle donations, campaign management, and
analytics for top campaigns and anomaly detection.
Sample Workflow
1. Users browse active campaigns and select one to donate to.
2. Users input a donation amount, which is validated (positive decimal, within daily
limit).
3. The backend processes the donation, updates the campaign total, and triggers
real-time UI updates.
4. The system flags unusually high donations and identifies top campaigns for
display.
Crowdsourced Event Planner with Real-Time Voting
Description
Develop a web-based platform for planning community events where users can
propose events, vote on event details (e.g., location, time), and view real-time voting
results. The system should support collaborative decision-making for events like
meetups or workshops.
Key Features
• Event Proposals: Users can create event proposals with details like title,
description, and suggested dates.
• Real-Time Voting: Users vote on event details, with live updates to vote counts
displayed in the UI.
• Pattern-Based Validation: Event titles must be at least 5 characters, dates must
follow YYYY-MM-DD format.
• Pattern Matching Rules: Identify the most popular event proposals based on
vote counts and flag low-participation events.
• Simple Rules: Prevent users from voting multiple times on the same event.
• Nice-to-Have: Integrate with Google Calendar API (free tier) to add confirmed
events to user calendars
Instructions
• Execution: Full implementation is required; design alone is insufficient.
• Open-Book Challenge: Use any online resources, AI tools, or documentation.
• Platform Choice: Any tech stack allowed (e.g., Angular/[Link], Flask/React).
• Evaluation Criteria: Problem-solving, implementation efficiency, creativity.
• API Requirement: Use open-source, free APIs (e.g., Google Calendar API, Web
Speech API).
• Deliverables:
o Frontend: Interface to propose events, vote, and view real-time vote
tallies (e.g., bar charts).
o Backend: APIs for event creation, voting, and analytics for popular
events.
Sample Workflow
1. Users propose an event with a title, description, and date.
2. Other users vote on the proposal, with votes validated to prevent duplicates.
3. The backend updates vote counts and triggers real-time UI updates.
4. The system identifies top events and flags those with low engagement.
5. Optional: Add confirmed events to Google Calendar
Sustainable Travel Planner with Carbon Footprint Tracker
Description
Develop a platform that helps users plan eco-friendly travel itineraries, calculating the
carbon footprint of transportation choices (e.g., bus, train, car) and suggesting greener
alternatives.
Key Features
• Itinerary Creation: Users create travel plans with destinations and transport
modes.
• Real-Time Carbon Tracking: Display carbon footprint updates as users select
transport options.
• Pattern-Based Validation: Destination names must be alphabetical, travel
dates must be valid (future dates only).
• Pattern Matching Rules: Identify high-carbon travel plans and suggest low-
carbon alternatives.
• Simple Rules: Prevent itineraries with conflicting dates (e.g., return before
departure).
• Nice-to-Have: Integrate with OpenRouteService API (free tier) for route planning
or OpenWeatherMap API (free tier) for weather-based travel suggestions.
Support multi mode transport system (Can’t use single transport system).
Assume start point is Chennai and colombo.
Instructions
• Execution: Full implementation is required.
• Open-Book Challenge: Use online resources, AI tools, or documentation.
• Platform Choice: Any tech stack allowed.
• Evaluation Criteria: Problem-solving, efficiency, creativity.
• API Requirement: Use open-source, free APIs (e.g., OpenRouteService,
OpenWeatherMap).
• Deliverables:
o Frontend: Interface to create itineraries, view carbon footprints, and see
eco-friendly suggestions.
o Backend: APIs for itinerary management, carbon calculations, and
alternative suggestions.
Sample Workflow
1. Users input a destination, transport mode, and travel dates.
2. The backend calculates the carbon footprint and validates dates.
3. The UI displays the footprint and suggests greener transport options.
4. The system flags high-carbon plans and proposes alternatives.
5. Optional: Fetch routes via OpenRouteService or weather data for travel planning.
Community Skill-Sharing Platform with Matchmaking
Description
Develop a platform where users can offer and request skills (e.g., coding, photography)
within a community, with automated matchmaking to connect skill providers and
learners.
Key Features
• Skill Listings: Users can list skills they offer or seek.
• Real-Time Matchmaking: Display matched users based on complementary skill
requests/offers.
• Pattern-Based Validation: Skill names must be alphabetical, descriptions at
least 10 characters.
• Pattern Matching Rules: Identify popular skills and flag inactive listings (e.g., no
activity for 7 days).
• Simple Rules: Prevent users from requesting their own offered skills.
• Nice-to-Have: Integrate with Google Maps API (free tier) to show nearby skill
providers.
Instructions
• Execution: Full implementation is required.
• Open-Book Challenge: Use online resources, AI tools, or documentation.
• Platform Choice: Any tech stack allowed.
• Evaluation Criteria: Problem-solving, efficiency, creativity.
• API Requirement: Use open-source, free APIs (e.g., Google Maps API)
• Deliverables:
o Frontend: Interface to list skills, view matches, and browse popular skills.
o Backend: APIs for skill listings, matchmaking, and analytics for popular
skills.
Sample Workflow
1. Users list a skill they offer or seek with a description.
2. The backend matches users based on complementary skills and validates
inputs.
3. The UI displays matches and popular skills in real-time.
4. The system flags inactive listings and prevents invalid requests.
5. Optional: Show nearby providers via Google Maps.
Web Application with Integrated Chatbot Navigation
Description
Develop a web application that allows users to explore into distinct webpages. The
application must integrate a chatbot that interprets user queries (e.g., "I need a
plumber" or "Find math tutoring") and navigates users to the most relevant webpage
within the application to address their query. The system should support real-time
updates and seamless webpage navigation driven by chatbot interactions.
Key Features
• Multi-Service Webpages: The application hosts multiple service categories
(e.g., Plumbing, Tutoring, Catering, Cleaning), each with a dedicated webpage.
• Chatbot-Driven Navigation: A chatbot processes user queries and redirects
users to the appropriate webpage within the application based on keyword or
intent matching.
• Real-Time Navigation Updates: Display dynamic webpage suggestions within
the chatbot interface and update webpage content in real-time.
• Simple Rules: Prevent navigation to a webpage if the query does not match any
service category.
• Nice-To-Have: If the pages are having sub sections navigate to sub sections as
well and performs actions in the website through chat bot.
Instructions
• Execution: Full implementation is mandatory; designing alone is insufficient.
• Open-Book Challenge: Candidates may use online resources, AI tools, or
documentation.
• Platform Choice: Candidates can choose any tech stack (e.g., React/[Link],
Vue/Flask, Angular/Express, etc.), and it will not impact evaluation.
• Evaluation Criteria: Focus on problem-solving, implementation efficiency, and
creativity.
• API Requirement: All APIs used must be open-source and free.
• Deliverables:
o Frontend: A user-friendly interface with service webpages, a chatbot
widget for query input, and dynamic navigation to relevant webpages
based on chatbot responses.
o Backend: APIs for service management, query processing, category
matching, and analytics for popular webpages and unmatched queries.
Sample Workflow
1. Users access the web application and interact with the chatbot by typing or
speaking a query (e.g., "I need a plumber for a leaky pipe").
2. The chatbot validates the query (minimum 5 characters) and processes it to
identify the best-matching service category (e.g., Plumbing).
3. Backend matches the query to a service webpage (e.g., /services/plumbing) and
returns the internal URL, triggering navigation in the frontend.
4. The system tracks webpage visits and flags vague queries (e.g., "Fix something"
with no clear match) for fallback responses (e.g., "Please specify the service you
need").
5. Frontend navigates to the matched webpage and displays service details in real-
time.
Implementation Notes
• Chatbot Logic: Implement a simple keyword-based matching system (e.g.,
"plumber" → Plumbing webpage, "tutor" → Tutoring webpage) .
• Navigation: Use client-side routing (e.g., React Router, Vue Router) to navigate to
internal webpages (e.g., /services/plumbing) based on chatbot responses.
• Webpage Structure: Each service webpage should display relevant details and
be accessible via a unique internal URL.
Example Queries and Navigation
• Query: "Find a plumber nearby" → Navigate to /services/plumbing webpage.
• Query: "Math tutoring for kids" → Navigate to /services/tutoring webpage.
• Query: "Catering for a party" → Navigate to /services/catering webpage.
• Query: "Help me" (vague) → Display fallback message in chatbot, flag for review.