PushPin

The self optimization platform that really knows you. "Let's get to work" -Sincerely, You.

Comment

Inspiration

PushPin came from a issue I kept noticing in student productivity tools, they're really great at helping you plan a day, but terrible at learning from the day you actually lived.

A calendar can tell you that you had a study block, a quiz, a meeting, and practice. But it cannot tell you which kinds of events consistently leave you fulfilled, or which ones make you extremely tired the rest of the day. I really wanted to build something that closes that gap, and actually knows how students live.

The idea behind PushPin is pretty simple, your planned schedule is only half the story. The more important half is what actually happened, how you felt, what patterns emerge from that over time, and even what you didn't do, because they are all important.

What it does

PushPin is a predictive student guidance product that connects schedule, reflection, and action.

It pulls in context from tools like calendars, email, and learning systems, then lets a student log quick check-ins after important events. From there, PushPin updates a live report that tracks fulfillment, preparation, and follow-through, identifies recurring patterns, and generates adaptive guidance for the rest of the day.

Instead of just showing what is on your calendar, PushPin tries to answer questions like:

  • What kinds of events tend to go well for you
  • Where do you consistently underprepare
  • Which blocks are likely to go off track unless you intervene early
  • How should one new reflection change the guidance you get next time

That makes it less like a static planner and more like a behavioral intelligence layer for student performance so everybody really knows their habits and PushPin plans around and with them.

How we built it

We built PushPin as a web prototype.

The frontend uses React + Vite and is focused on the actual product experience rather than a landing page. We used TanStack Query for data flow, React Router for navigation, Zod for contract validation, and custom Canvas-based visualizations for the trajectory section of the report.

The backend uses Node.js + Express and exposes routes for reports, check-ins, connector status, actions, and demo state resets. For the intelligence layer, we integrated the Claude API using Claude Haiku 4.5 to generate pattern summaries, adaptive noon nudges, check-in questions, and intelligence findings.

We also built the product around the real systems that shape a student's day, including:

  • Google Calendar
  • Gmail
  • Outlook
  • Canvas LMS

For the demo, these integrations run through a realistic shared-state prototype flow so the product can still behave end-to-end and show how readiness, reporting, and reflection all connect.

Challenges we ran into

The hardest challenge was keeping the product truthful.

PushPin only works if every surface agrees with every other surface. If Connect says delivery is ready but Report still says it is blocked, the entire illusion breaks. A lot of the hardest work was making sure the report, the connector state, the check-in system, the AI-generated guidance, and the activity log all stayed aligned. Especially in the initial prototyping stages, where front-end work and back-end work were split, the integration with each other was extremely difficult.

Another more minor but still relevant challenge was resisting the temptation to oversell the AI. We wanted PushPin to feel advanced, but still real.

Accomplishments that we're proud of

We are proud that PushPin feels like a real product rather than just a concept.

Some of the things we are most proud of are:

  • building a capable and unique product loop to fully utilize the report page
  • making one short check-in meaningfully change the report rather than just put a dent
  • creating a product that feels predictive instead of just descriptive
  • keeping the system transparent, so readiness, dependencies, and connector states stay visible
  • turning a complex behavioral idea into a clean demo flow that can be understood quickly

What we learned

We learned that the most useful AI products are not the ones that generate the most text. They are the ones that sit inside a real feedback loop.

PushPin taught us a lot about building around trust, consistency, and behavior rather than novelty alone. We learned how important it is to make product state legible, how difficult it is to keep AI copy aligned with live system state, and how much stronger a product becomes when it reacts to user behavior instead of only presenting information.

We also learned that students do not just need more planning tools. They need tools that help them notice patterns in how they actually perform and adapt before the next important moment slips away.

What's next for PushPin

  • replacing in-memory demo state with durable storage
  • implementing full OAuth callback and disconnect flows
  • making delivery jobs more persistent
  • improving the predictive model so it can become more personalized over time, maybe with a more advanced memory system?
  • expanding PushPin from a noon report into a broader real-time student guidance system with email check-ins rather than web based check-ins
  • fully implement TimesFM into the predictive analysis for more accurate projections

Long term, we want PushPin to become a system that does more than help students organize their time. We want it to help them understand how they work, where they struggle, and how to intervene earlier with better self-awareness.

Built With

Share this project:

Updates