Termwise

Inspiration

Small firms lose money to contracts nobody is watching. A hosting deal renews for another year because nobody sent notice 30 days before the term ended, and that date was never written down: it has to be worked out from the start date, the term and the notice clause, which sit in three places. Enterprise contract suites exist but are priced and staffed for companies with legal teams. A 40-person firm has a shared drive and a spreadsheet.

I also wanted a contract tool people could trust with money. Tools that summarise with a language model can state a plausible date that is not in the contract. For a deadline that commits lakhs of rupees, a plausible date is worse than none.

What it does

Termwise reads a contract, splits it into clauses, and finds the terms that create a date or a duty: renewal windows, notice periods, payment terms, breach notification windows, service credit claims, insurance, lock-ins, fee escalations, data return on exit. It works out which party each one binds, based on the side of the contract you are on, and computes the actual deadlines with the arithmetic visible: start date plus term minus notice, each figure linked to the sentence it came from.

Every obligation goes into one register with an owner, a status and a note, and into Google Calendar or Outlook through a private feed. Nothing is final until a person confirms it; rejecting a finding needs a reason, and anything computed from it drops out. Every change is written to a hash-chained audit log that verifies itself and names the exact event if anyone edits the history.

Owners get four enforced roles, full workspace export, and erasure that removes contract text while the log keeps a hash as proof of what was deleted.

Try it: the "Open the live demo" button on https://termwise-app.netlify.app makes a private workspace with four sample contracts. No sign-up.

How I built it

Node on a single Netlify Function using web-standard Request and Response, with Netlify Blobs for storage and no other dependency. The front end is plain ES modules with no build step, and it builds DOM nodes directly so contract text is never parsed as HTML.

The extraction engine is deterministic: each rule locates a kind of term and returns the sentence with its character offsets. It never writes text. The test suite checks, for every sample contract, that each quote equals the text at its offsets and that every number a finding reports appears inside that quote.

Blobs has no transactions, so everything that must not race is built on conditional writes. Plan limits are checked inside a compare-and-set on the workspace index. Audit event N is written create-only, so two writers cannot both claim it; the loser re-links to the winner's hash.

Architecture, key schema, security model and governance controls: docs/ARCHITECTURE.md. Executive briefing: docs/BRIEFING.md. Monetisation blueprint: docs/MONETISATION.md. All in https://github.com/ramsai676/termwise

Monetisation

Subscription per workspace: Starter free (5 contracts, 2 people), Team Rs 1,999 a month (150 contracts, 10 people, calendar feed, audit export), Business Rs 7,999 a month (2,000 contracts, 50 people). Every limit is enforced by the API. No per-document inference cost, so margins stay high. Growth through self-serve, the no-signup demo, and chartered accountant partners who already run statutory calendars for small firms.

Challenges I ran into

• Contracts put the whole paragraph on the numbered line, so clause detection cannot reject long lines.
• "The Contractor shall invoice monthly and the Client shall pay within 15 days": the duty belongs to the party nearest the verb, not the first one named.
• An auto-renewing contract whose notice window has already passed needs to say which renewal was missed and roll to the next window, not show a negative countdown.
• Making erasure honest. The first version logged a snippet of each reviewed finding, which meant deleted contracts left text in the audit log. Reviews are now logged by type, clause and a hash of the quote, and a test searches every stored key for contract text after erasure.

Accomplishments that I'm proud of

• A deadline you can check in ten seconds by reading the highlighted sentence.
• Tamper detection that works: edit any past event in storage and verification names it.
• 40 automated tests, including parallel-request tests for plan limits and the audit chain.

What I learned

Governance features are only worth something if they are enforced where a user cannot reach them. Every limit, role and gate in Termwise is checked by the server, and each claim on the landing page has a test behind it.

What's next for Termwise

PDF and Word import, email reminders to owners, a chartered accountant partner plan so one CA firm can manage contract calendars for many client firms, and live payments behind the existing plan endpoint.

Built With

• css3
• html5
• javascript
• netlify
• netlify-blobs
• node.js