Contract Compass

Contract Compass Logo

Inspiration

The inspiration came from a simple observation: legal teams are drowning in document chaos.

We watched lawyers spend entire afternoons manually piecing together contract amendments, often missing critical changes or working with outdated terms. A single contract could spawn 5–10+ related documents—amendments, riders, exhibits, side letters—creating a complex web that's nearly impossible to navigate efficiently.

The breaking point was realizing that while software developers have sophisticated version control systems to track every code change, legal professionals are still stuck in a world of manual document reconciliation.
We thought: "What if we could bring that same clarity and automation to legal agreements?"

But this story isn’t just about a problem—it’s also about who came together to solve it.

A group of diverse women technologists, product thinkers, and AI enthusiasts joined forces—many of us meeting through the Women Defining AI community. What began as individual curiosity transformed into collaborative innovation, fueled by our shared passion to build something practical, inclusive, and impactful.

Together, we brought our unique lenses—from legal tech, HR, AI prompt design, UX, product strategy, and engineering—to reimagine how contracts evolve and how legal teams could reclaim control and clarity.

This wasn’t just a technical challenge—it was a real business problem tackled by a team that reflects the future of AI: diverse, mission-driven, and collaborative.

What it does

It acts like an automated paralegal. You upload a base contract and all its related documents (amendments, addenda). The engine reads them all, intelligently pieces them together in the right order, and produces a single, clean master document that reflects all the current terms. It also generates a simple summary of what changed, when, and why, both by document and by section.

1. The Problem with Current Contract Management

Managing contracts involves numerous related documents (amendments, riders, exhibits).
Requires manual review and reconciliation of each document to understand current terms.
Legal and business teams spend hours confirming details like termination dates and payment terms.

2. Introducing Contract Compass

Introducing Contract Compass

Contract Compass is an AI platform designed to streamline contract management.
It transforms contract versioning chaos into clarity in just 30 seconds.

3. Demonstration of Contract Compass

Demo Screenshot

Start by creating a project (e.g., MSAs, NDAs, vendors).
Upload contracts easily using drag and drop (supports PDFfiles up to 10 MB).

4. Automatic Text Extraction and Classification

Text Extraction Screenshot

Text extraction occurs automatically during upload.
AI classifies each document and organizes them behind the scenes.

In under 30 seconds, receive:

✅ A clean, unified contract with all current terms
📄 A plain-English changelog summarizing what changed, when, and in which document

5. Example of Changes Tracked

Change Log Summary

See line by line changes and which document they come from.

6. Review Changes and Audit Trail

Snapshot of a Project

Unified contract includes:
- 📜 Complete document + incorporation history

7. User Accessibility

User Types Screenshot

Designed for a wide range of users:
- 🏢 In-house counsel managing vendor agreements
- ⚖️ Law firms reviewing client contracts
- 📑 Procurement teams verifying renewal terms
- 👥 Business stakeholders needing clarity on contract status

✅ Contract Compass simplifies and streamlines contract management
🚀 Try it out—see, use, and simplify your contract stack

How we built it

Frontend

Framework: React (built using Bolt.new for rapid prototyping)
Platform: Supabase
- Authentication
- Database
- File storage
Model: OpenAI GPT‑4.1 via Response API
- Clause extraction
- Document classification
- Synthesis of final contract with changelog
Text Extraction: pdfjs-dist for parsing PDF content
Tools: jspdf for generating downloadable PDF/DOCX files
Netlify
Deployed the entire web application using Netlify for fast, serverless hosting with automatic build and deploy pipelines directly from our GitHub repo.

Challenges we ran into

🤝 Collaboration & Version Control

🔥 1. Live-Wire Collaboration

Problem: Multiple team members pushing changes simultaneously caused UI conflicts and overwrote each other's work.

Solution: Established clear branch management and implemented real-time conflict resolution protocols.

🔀 2. Git Learning Curve

Problem: Some team members were unfamiliar with Git, leading to version control errors and collaboration roadblocks.

Solution: Adopted simplified Git workflows, offered pair programming sessions, and created lightweight documentation for daily use.

🔄 3. GitHub Integration Failures

Problem: Fork merges became problematic when multiple team members modified the same files. Sync failures occasionally required full repo resets.

Solution: Defined strict merge windows, used clear roles during pull requests, and created backup repositories to prevent project loss.

⚙️ Platform & Tooling Constraints

🤖 4. BOLT's Selective Responsiveness

Problem: BOLT sometimes failed to respond to prompts, stalling progress at critical moments.

Solution: Set up fallback workflows and maintained direct code access to intervene quickly when needed.

🔁 5. Illusion of Update in BOLT's Vibecoding Flow

Problem: BOLT often indicated that logic had been updated, but the changes weren't actually reflected in the app—causing looping behavior and lost time.

Solution: Introduced redundant validation steps, such as snapshot testing and manual overrides, and maintained alternate paths for syncing logic.

🐛 6. Silent Logic Bugs in BOLT

Problem: BOLT occasionally generated bugs (like infinite loops) that didn’t crash the app or throw visible errors, making them hard to detect.

Solution: Manually debugged and resolved the issue. After that, updates were more stable. We added post-update logic verification as a standard practice.

🎯 7. Understanding Tool Boundaries

Problem: Uncertainty over what BOLT could or couldn’t do led to trial-and-error and inefficient use of resources.

Solution: Created a capabilities matrix and routing logic to decide when to use BOLT vs. direct OpenAI API or manual code.

📄 Document Processing & AI Logic

📄 8. Document Parsing Nightmares

Problem: DOCX and PDF parsing was unreliable due to inconsistent formatting, embedded objects, and encoding issues.

Solution: Built a preprocessing pipeline using multiple libraries with layered error handling to normalize inputs before AI processing.

🔧 9. JSON Interpretation Struggles

Problem:
BOLT struggled to generate or interpret deeply nested JSON structures essential for clause mapping and document synthesis. Solution:
Moved to custom OpenAI API calls with detailed schema definitions and prompt engineering to ensure predictable output.

📚 10. Teaching AI Legal Precedence

Problem: Handling multiple amendments with overlapping or same-day timestamps required careful logic to determine which clause should win.

Solution: Developed a precedence engine using effective dates, clause context, and user-defined overrides to handle edge cases gracefully.

⚖️ 11. Preserving Legal Language Integrity

Problem: AI models tried to “improve” legal language instead of preserving it word-for-word, threatening legal accuracy.

Solution: Used strict prompt instructions and added no-modification flags for sensitive clauses to maintain legal integrity.

🧩 12. The Precedence Puzzle

Problem: When two amendments modified the same clause with the same effective date, it created ambiguity.

Solution: Combined user-defined precedence with AI-powered conflict detection and flagged unresolved conflicts for human review.

📈 UX & Performance

📐 13. Maintaining Professional Standards

Problem: Legal documents require strict formatting—incorrect headings, numbering, or fonts can undermine credibility.

Solution: Built a template-based export system that preserved formatting, structure, and styling from the original documents.

⚡ 14. Performance Under Pressure

Problem: Waiting several minutes for results isn't acceptable in fast-paced legal environments.

Solution: Optimized the processing pipeline and prompt efficiency to deliver reliable results in under 30 seconds, even for multi-document stacks.

Accomplishments that we're proud of

1.Tackled a Real Legal Ops Problem

We built a functional AI-powered solution for messy contract stacks—handling amendments, clause conflicts, and legal precision with clarity and speed.

2.Shipped in 4 Weeks

From idea to deployed web app with:

React + Supabase backend
AI clause synthesis via GPT-4.1
Seamless Netlify deployment

3.AI That Goes Beyond Summaries

Our engine handles:

Clause-level comparison across amendments
Precedence logic + plain-English changelogs

4.Prompts That Perform

Achieved 85%+ clause matching accuracy with structured outputs, tested across real-world PDFs and DOCX formats.

5.First-Time, Remote, Diverse Team

Met through the Women Defining AI community, overcame time zones, tool quirks, and Git chaos—and delivered.

6.We Debugged Everything

From infinite loops to invisible bugs, we hit edge cases early and built safeguards that made our product stronger.

What we learned

1. AI Needs Guardrails

LLMs are powerful, but not always predictable. Precision use cases like contracts demand structured prompts, fallback logic, and strict output formatting.