Forj | Devpost

What it does

Most productivity tools are very good at recording intention: tasks created, plans scheduled, and streaks maintained. Forj records the harder thing—what actually happened.

You begin with one concrete task and a focus window. When the session ends, you record the outcome honestly: Done, Partial, or Didn't happen. Every result is valid. Forj then preserves the session in a private evidence archive, so progress is based on work you actually kept rather than a perfect-looking plan.

The archive includes a GitHub-inspired activity grid whose intensity reflects confirmed focused time, not a simplistic session count. A 50-minute session carries more weight than a two-minute check-in, and a partial result still remains evidence that you returned to the work.

Completed sessions are private by default. If a person chooses, they can publish a deliberately limited receipt to a small community feed. Sharing is reversible: revoking a receipt removes its public link and feed post while preserving the underlying private session.

The problem

For someone who keeps making plans but struggles to start, another to-do list often creates more planning—not more action. Streak-based products can make one missed day feel like failure, while public accountability can turn personal work into performance.

Forj is for students, creators, independent builders, and anyone who needs a quieter form of accountability. It asks for only one promise at a time:

“Draft the introduction for 25 minutes.”

At the end, Forj does not ask whether the day was perfect. It asks what happened and preserves the answer. Over time, that creates something more useful than a streak: a trustworthy record that says, I showed up, this is what I did, and I can return tomorrow.

How it works

Name one specific task concrete enough to act on now.
Choose a focus duration and create a defined space for the work.
Record the real outcome: Done, Partial, or Didn't happen.
See evidence accumulate in a private archive and time-weighted activity grid.
Add community context when useful.
Share only by choice, with a deliberately limited receipt that can be revoked at any time.

Why we built it

The original product question was not “How do we build a better timer?” It was “What would help someone trust themselves again after many plans did not become action?”

That changed the design. We chose evidence over intention. We made Partial a first-class outcome. We rejected punishing streaks and public leaderboards. We made privacy the default, sharing explicit and reversible, and progress reflect confirmed focused time rather than easy-to-game check-ins.

Forj is intentionally calm. Its job is not to pressure people into appearing productive. Its job is to help them notice that returning to the work counts.

Technical implementation

Forj is a Next.js, React, and TypeScript application deployed on Vercel, with Supabase Authentication and Postgres for account-scoped persistence.

Focus sessions, confirmed focused time, outcomes, evidence summaries, and public share artifacts are canonical, account-owned records. Focus-session actions use explicit server boundaries, input validation, ownership checks, row-level access controls, and idempotency so retries do not silently duplicate or corrupt evidence.

Public receipts expose only intentionally shareable fields rather than returning the private source record. Revocation removes the public artifact and its feed presence while retaining the owner’s private session. We also hardened shared-browser account switching so cached evidence from a previous account cannot briefly render during a new authentication transition.

How we used Codex and GPT-5.6

Codex and GPT-5.6 were engineering collaborators throughout the build—not a decorative chat feature.

They helped us explore product flows, reason through canonical session and receipt boundaries, implement authenticated Next.js and Supabase paths, and challenge failure cases including duplicate completion requests, unauthorized record access, stale account data, receipt revocation inconsistencies, validation gaps, and confusing timer states.

The human product decisions remained ours: one concrete task, three honest outcomes, private-by-default evidence, time-weighted progress, and reversible receipts. Codex accelerated implementation, critique, testing, and verification.

What we learned

Accountability does not have to mean surveillance, pressure, or performance. A record can be truthful and motivating at the same time. We also learned that privacy depends on transitions as much as storage: authorization can be correct on the server while stale client state still creates a brief exposure.

What's next

We want to make evidence more meaningful without making it noisier: optional private notes or attachments, personal reflections, small purpose-driven communities with strong privacy controls, export and deletion tools, and gentle return prompts based on a person’s own patterns—not shame-based streaks.