My Friend Didn't Need Another Reminder App — She Needed Accountability

Apoorv Singh — Sun, 04 Oct 2026 16:53:12 +0000

**My friend has a simple problem: she forgets things, and she also forgets to check the apps that are supposed to remind her.

A reminder inside a productivity app isn't very useful if you never open the productivity app.**

That made me think about a different kind of productivity assistant.

Instead of putting all the responsibility on the person who is trying to stay organized, what if a trusted friend could help keep their tasks on track?

That's why I built Nudgify.

Nudgify is a productivity and trusted-delegation assistant where users can give trusted people different levels of permission to help manage their tasks.

For example, a friend can say:

"Move my DBMS assignment deadline to Friday."

Nudgify interprets the request, checks whether that person has permission to make the change, updates the task, records the activity, and can notify the affected user.

The idea is simple:

Don't just remind people. Let the people they trust help them stay on track.

Demo

Live Demo: https://nudgify.ai.studio/

GitHub: https://github.com/vendetta2025/hactoberfest1

The main flow I'd recommend trying is:

Create a task.
Add a trusted person.
Ask Nudgify to modify a task using natural language.
See the permission-aware action.
Check the notification/activity history.

Code

The project is publicly available on GitHub:

https://github.com/vendetta2025/hactoberfest1

The repository contains the frontend, backend, task logic, authentication, permission handling, and notification infrastructure.

How I Built It

I built Nudgify as a full-stack web application using React, TypeScript, Vite, and an Express backend. The repository also includes Web Push support for browser notifications.

The interesting part of the architecture is the separation between AI interpretation and application authority.

The AI should be able to understand something like:

"Move my DBMS deadline to Friday."

and turn that into a structured action.

But the AI should NOT be trusted to decide whether the action is allowed.

The backend performs the actual authorization and executes the change.

Conceptually:

User → Natural Language → AI interpretation → Structured Action → Permission Check → Database → Notification

This means the model handles the flexible, human part of the interaction while deterministic application code handles the sensitive part: who is allowed to do what.

I also built the notification layer around Web Push so that task-related events don't have to depend entirely on someone constantly keeping the application open.

Why Does Open Innovation Matter?

For Nudgify, open innovation is important because the AI layer should be something I can understand, experiment with, replace, and adapt rather than treating it as an untouchable black box.

The project is designed around a separation between the AI layer and the deterministic application layer.

That separation means I can experiment with different AI models for natural-language understanding without giving the model direct control over permissions or the database.

The bigger lesson for me was that AI doesn't need to control everything to be useful.

For a productivity assistant dealing with another person's tasks, I actually want the opposite:

Let AI handle ambiguity. Let code handle authority.

That makes the system easier to reason about and gives me much more control over how the assistant behaves.

Building Nudgify also made me realize how much a real user's problem changes the design of a product. I initially thought about building another reminder app. Once I focused on the actual person I was building for, trusted delegation became the central idea instead.

This project is still a work in progress, but the core idea is something I want to continue developing: a productivity assistant that doesn't just tell you what you forgot — it lets the people you trust help you remember.