How Codemonk Built an AI-Powered Contract Management System for a Leading Renewable Energy Developer

The Challenge

The Developer manages a large and growing portfolio of solar EPC and O&M contracts. These contracts are complex — typically five or more separate documents (Invitation to Bid, General Conditions of Contract, Special Conditions of Contract, Technical Specifications, and the Contract Agreement itself), each running into hundreds of pages, with their own order of precedence governing how conflicts between them get resolved.

The commercial and contracts team was spending the bulk of its time on work that is critical but fundamentally clerical: reading dense documents, extracting key parameters, identifying missing clauses, and tracking obligations across the contract lifecycle. That left less time for the judgment work the team actually exists to do — risk assessment, negotiation strategy, obligation management.

Specifically, the Developer came to Codemonk with:

• Manual extraction of critical parameters (liquidated damages, bank guarantees, payment milestones, defect liability period, warranty terms) from multi-document contract sets — slow and error-prone
• No systematic way to check a received contract's clauses against the Developer's own standard clause library
• Order-of-precedence conflicts across documents resolved informally, with no system support
• Obligation tracking disconnected from the contract documents themselves — living in spreadsheets or email threads
• No single system of record spanning the contract lifecycle from pre-bid through closure.

The Approach

The central design decision was to treat the AI as a research assistant that shows its work, not a black box that hands down conclusions — because every output feeds a legally binding document. Two choices followed directly from that:

Every extracted value is cited back to a source document and page. Rather than presenting a summary the reviewer has to trust blind, the platform lets a reviewer verify any figure — an LD rate, a BG timeline, a payment milestone — in one click against the actual contract text. This matters more here than in a typical document-automation use case, because the artifact being summarized is the thing that governs a commercial dispute if something is misread.

When a parameter conflicts across documents, the system flags it — it doesn't guess. Multi-document contracts routinely say different things about the same parameter in different places, and which one governs depends on the contract's own order-of-precedence clause. Codemonk designed the Order of Precedence module to surface the conflict explicitly and let the commercial team make the binding call, rather than have the model silently pick one — a wrong automated guess here carries real commercial and legal risk, so the system's job is to make the conflict impossible to miss, not to resolve it on the team's behalf.

That same reasoning shaped the chatbot: it's built on Retrieval-Augmented Generation specifically so answers are grounded in the actual uploaded documents rather than a generic model's best guess — a deliberate trade against generic chat convenience, in favor of an answer the Developer's team could act on with confidence.

Finally, because contracts move through multiple negotiation rounds — pre-bid draft, post-bid revisions, final agreement — version lineage needed to be a first-class feature, not an afterthought. Documents carried forward from a prior version are marked as sourced from that version and locked against being silently renamed, so the team is never unsure which round of negotiation a given clause came from.

The Solution

Codemonk designed and built an end-to-end AI-powered Contract Management System — a web platform covering the full contract lifecycle from pre-bid document review through post-bid finalisation and contract closure.

Contract Workspace. Every contract lives in a structured workspace, with metadata captured at creation — Project Name, Location, Business Type (Large Projects / Rooftop), Project Type, Contract Value, GST, Capacity, Client Name. Contracts are searchable and filterable by type, business unit, financial year, and status, giving the team a single view of the entire portfolio.

Versioned Document Management. Documents are uploaded and organized under versioned sections — Version 1 for pre-bid, Version 2 onward for post-bid iterations — with lineage tracked automatically. Marking a version Post Bid updates the contract's status; if documents change after a summary has already been generated, the system detects the change and prompts re-generation, so nothing goes stale silently.

AI Insights Extraction — the core engine. Once documents are uploaded, an automated extraction pipeline runs:

• Tender Summary — a structured summary covering LDs, bank guarantees, payment terms, delivery timelines, termination clauses, warranties, force majeure, jurisdiction, and more, every value cited to its source document and page
• Order of Precedence Resolution — surfaces conflicting values across documents for the team to resolve, rather than resolving them automatically
• Critical Parameters — LD rates, BG types and timelines, limitation-of-liability caps, execution timelines, PG/PR commitments, all cited
• Clause Presence Identification — checks uploaded documents against a required clause list and reports what's present (with source and page) and what's missing
• Clause Gap Analysis — compares contract clauses against the Developer's own standard reference document and highlights deviations, functioning as the negotiation-intelligence layer

Document Chatbot (RAG-based Q&A). Once a version's summary is generated, the full document set becomes conversational — users can ask questions like "What is the PG test obligation and associated BG value?" and get precise, cited answers grounded in the actual contract documents. The chatbot is version-aware and re-locks if the underlying documents change.

Closure Checklist. A structured digital checklist tracks contract closure milestones — EPC handover, punch-point closure, EPC and O&M payments, and every bank-guarantee type (ABG, commissioning BG, DLP BG, O&M BG, warranty BG, module warranty BG, PG test BG) — each marked Yes/No/NA with a remarks field, replacing informal tracking across email and spreadsheets.

Task Management. Obligation-related tasks can be created within a contract, assigned to any team member, and tracked to a To-Do/Done status, with team-visible comments for auditable collaboration.

Dashboard. An executive view of the whole portfolio — total contracts split by Open/Closed, segmented by Business Type and Project Type, with contract values listed.

SSO & User Management. Login runs through the Developer's own domain SSO — no separate password management — with admins configuring Project Type and Business Type access per user, so data governance doesn't cost the team friction.

The Impact

The platform is live in production with the Developer's commercial contracts team, functioning as their system of record across the full contract lifecycle — not a pilot or a proof of concept sitting alongside the old process.

Practically, that means: a multi-document, 100+ page contract set that once required hours of manual cross-referencing now gets a structured, cited AI summary in one pass; clause gaps and order-of-precedence conflicts that used to depend on one reviewer's memory or attention are now systematically surfaced; and obligation tracking that lived in spreadsheets and inboxes now lives inside the same system as the source documents. Every contract gets processed with the same rigor regardless of which team member is handling it or how much bandwidth they have that week.