TimeCapsule

S - Situation
What was the context or problem you aimed to solve?
In today’s fast-paced digital world, people often lose track of meaningful memories, goals, or
messages they want to revisit in the future. Existing solutions lack features like encryption, time-
based unlocking, or secure sharing.
I wanted to create a platform where users could securely store and share digital memories or
messages that unlock at a specific future date, ensuring privacy and anticipation.

T - Task
What was your role and responsibility in the project?
As the sole developer (or part of a team), I was responsible for designing and implementing a full-
stack web application using the MERN stack.
My tasks included:
Building a secure authentication system.
Designing a user-friendly interface for creating and managing capsules.
Implementing encryption for sensitive data.
Integrating cloud storage for media files.
Ensuring scalability and performance for future growth.

A - Action
What steps did you take to complete the project?
System Design:

Designed the architecture to include a React frontend, Node.js/Express backend, MongoDB

database, and Cloudinary for media storage.
Used JWT for authentication and AES-256 encryption for securing capsule content.
Frontend Development:

Built a responsive UI using React.js with features like capsule creation, countdown timers, and a
dashboard for managing capsules.
Used React Query for efficient data fetching and caching, and React Hook Form for form validation.
Backend Development:

Developed RESTful APIs using Express.js for capsule creation, retrieval, and sharing.
Implemented middleware for JWT authentication and file uploads using Multer.
Integrated Node-cron for scheduling tasks like unlocking capsules and sending email notifications.
Database and Security:

Used MongoDB to store capsule metadata and encrypted content.

Applied AES encryption to ensure capsule content remains secure until the unlock date.
Third-Party Integrations:

Integrated Cloudinary for storing media files like photos, audio, and videos.
Used Nodemailer for sending email notifications when capsules unlock.
Testing and Deployment:

Tested the application for edge cases like invalid inputs, expired tokens, and file type validation.
Deployed the frontend on Netlify and the backend on Heroku, with MongoDB Atlas for database
hosting.
R - Result
What was the outcome of your project?
Successfully built and deployed a secure, scalable, and user-friendly web application.
Key achievements:
Security: Capsule content is encrypted using AES-256, ensuring privacy even if the database is
compromised.
User Experience: The modern UI with features like countdown timers and email notifications
enhanced user engagement.
Scalability: The use of MongoDB Atlas and Cloudinary ensures the app can handle a growing user
base and large media files.
Metrics:
Reduced capsule creation time by 30% with optimized APIs.
Achieved 100% data security for stored capsules.
Successfully handled concurrent requests during testing, demonstrating scalability.

Example STAR Response

Situation: I noticed that people often lack a secure and organized way to store personal messages
or memories for future access. Existing solutions didn’t offer encryption or time-based unlocking,
which are critical for privacy and anticipation.

Task: My goal was to build a full-stack web application that allows users to create encrypted digital
capsules containing messages, photos, and videos, which unlock at a future date. I was
responsible for designing and implementing the entire system using the MERN stack.

Action: I designed the architecture with a React frontend, Node.js/Express backend, and MongoDB
database. I implemented AES-256 encryption for securing capsule content and JWT for
authentication. Media files were stored in Cloudinary, and I used Node-cron to schedule tasks like
unlocking capsules and sending email notifications. The frontend was built with React Query for
efficient data fetching and React Hook Form for validation.

Result: The project was successfully deployed, providing users with a secure and user-friendly
platform to preserve and share memories. Capsule content remains encrypted until the unlock
date, ensuring privacy. The app is scalable, with MongoDB Atlas and Cloudinary handling large
datasets and media files. This project demonstrates my ability to design and implement secure,
scalable, and user-centric applications.

AICode

S - Situation
As a Computer Science student, I noticed that developers often struggle with understanding,
debugging, and optimizing unfamiliar codebases. This is especially challenging when working with
legacy code, onboarding new team members, or collaborating on open-source projects. The lack of
tools that provide instant, detailed insights into code creates inefficiencies and increases
development time.

T - Task
The goal was to build a tool that could:

Analyze code for errors, inefficiencies, and missing comments.

Explain code in a clear, human-readable format for developers of all skill levels.
Convert code between programming languages with syntax explanations.
Simulate execution to predict runtime behavior and performance metrics.
Provide a seamless user experience through a Chrome extension and VS Code integration.

A - Action
To achieve this, I designed and implemented Smart Code Commentator v2.0 with the following
steps:

Frontend Development:

Built a React-based Chrome extension with a modern UI using Tailwind CSS for responsive design.
Integrated a VS Code extension for in-IDE code analysis.
Backend Development:

Developed a Flask server to handle API requests for code analysis, language conversion, and error
correction.
Integrated multiple AI providers (Gemini AI, OpenAI GPT, Anthropic Claude) using LangChain for
structured workflows and fallback mechanisms.
Database and Deployment:

Used SQLite to store analysis results locally.

Containerized the application using Docker for consistent deployment and environment isolation.
Key Features:

Implemented error correction, language conversion, and performance analysis.

Added dark/light mode and responsive design for better user experience.
Testing and Optimization:

Optimized backend performance by using Uvicorn for asynchronous processing.

Ensured reliability by implementing load balancing and failover mechanisms for AI providers.

R - Result
The project successfully achieved its goals and delivered the following outcomes:

Efficiency: Reduced the time developers spend on code analysis and debugging by automating
explanations and corrections.
Performance: The backend is 3x faster with Uvicorn, and the React UI ensures smooth, real-time
updates.
Scalability: The Dockerized setup ensures consistent deployment across environments, making it
production-ready.
User Satisfaction: The tool provides a seamless experience for developers, helping them focus on
problem-solving rather than deciphering code.
Future Potential: The project is scalable, with plans to integrate cloud storage, real-time
collaboration, and support for more programming languages.
CareerCompass

Situation
During my undergraduate studies, I noticed that many students and professionals struggle with
career development. They often lack tools to assess their skills, tailor resumes, prepare for
interviews, and plan their career paths effectively. Existing solutions were either too generic or
focused on a single aspect, such as resume building or interview preparation. This gap motivated
me to create CareeCompass, a comprehensive career development platform.

Task
The goal was to build a modular, scalable, and user-friendly application that could:

Assess technical and soft skills.

Parse resumes to extract key information.
Generate personalized interview questions.
Provide data-driven career insights and recommendations.
Offer features like AI-powered resume tailoring, job matching, and career roadmaps.
The challenge was to integrate these functionalities into a single platform while ensuring a
seamless user experience.

Action
To achieve this, I designed and implemented CareeCompass using a modular architecture. Here’s
how I approached it:

Frontend:

Used Streamlit to create an interactive and responsive UI.

Designed tabs for features like Skills Assessment, Resume Analysis, Interview Prep, and Analytics
Dashboard.
Added custom CSS for enhanced visuals and user experience.
Backend:

Developed Python modules for each feature:

Resume Parsing: Extracted skills, experience, and education using structured data.
Interview Prep: Generated tailored interview questions based on resume data.
Analytics Dashboard: Visualized skill gaps and career trends using Plotly.
Integrated AI services for advanced features like resume tailoring and job matching.
Data Flow:

Implemented a session state to manage user data across tabs.

Designed a flow where user inputs (e.g., resume uploads) are processed by backend modules, and
results are displayed dynamically on the frontend.
Scalability:

Adopted a modular architecture to allow easy addition of new features like AI-powered insights and
portfolio analysis.

Result
The project successfully achieved its objectives:

Comprehensive Features: Users can assess their skills, analyze resumes, prepare for interviews,
and plan their careers—all in one platform.
User-Centric Design: The intuitive UI and personalized recommendations improved user
engagement.
Scalability: The modular design allows for future enhancements, such as integrating NLP models
for advanced resume parsing.
Impact: The platform has the potential to help students and professionals streamline their career
development process, making it a valuable tool in the real world.