Contract Management Platform

• Let legal teams author contracts from structured templates and a reusable clause library
• Support real-time, multi-user document collaboration during negotiation
• Provide full version history with document comparison between revisions
• Route contracts through configurable multi-step approval workflows
• Enforce role-based access so only authorized users can view, edit, or approve a given contract
• Keep every action — edit, approval, access — in an auditable trail

The frontend is structured around one contract entity that every module reads from and writes to through a shared Redux Toolkit slice, so the Authoring, Clause Library, Repository, and Collaboration views are always looking at the same state rather than four separate copies of it. Real-time changes — a teammate editing a clause, a status change in the approval workflow — arrive over a SignalR connection and are dispatched into that same Redux state, so every open module updates consistently instead of each screen polling independently.

Each module (Authoring, Clause Library, Repository, Collaboration, Approval Workflow, and so on) is organized as its own feature folder with its own components, Redux slice, and API calls, following the same internal pattern so a new module could be added without re-learning a different structure. Shared primitives — data tables, form controls, modals — were built once as a reusable component layer using Shadcn UI and Radix UI primitives, and consumed by every module rather than being recreated per feature.

src/
├─ app/
│  ├─ contracts/
│  │  ├─ [contractId]/
│  │  │  ├─ authoring/page.tsx
│  │  │  ├─ collaboration/page.tsx
│  │  │  └─ approval/page.tsx
│  │  └─ repository/page.tsx
├─ features/
│  ├─ authoring/
│  │  ├─ authoringSlice.ts
│  │  ├─ components/
│  │  └─ api/
│  ├─ clause-library/
│  ├─ repository/
│  ├─ collaboration/
│  │  ├─ collaborationSlice.ts
│  │  └─ use-signalr-connection.ts
│  ├─ approval-workflow/
│  ├─ version-management/
│  └─ notifications/
├─ components/ui/            # shared Shadcn/Radix-based components
├─ lib/
│  ├─ api-client.ts
│  └─ auth/

Each module owns a Redux Toolkit slice scoped to its own concern (authoring draft state, clause library filters, approval workflow stage), while contract-level data that multiple modules need — status, participants, current version — lives in a shared contract slice referenced by all of them. This kept module-specific state changes from leaking into unrelated screens, while still giving every module a single, consistent view of the contract itself.

The frontend consumes a REST API backed by a .NET service for standard CRUD operations (drafts, clauses, approvals, audit entries), while live collaboration and notification events are delivered over a persistent SignalR connection rather than polling. A shared API client layer handled request/response typing, auth headers, and error normalization, so individual modules didn't each reimplement their own fetch logic.

Authentication is handled via JWT — the token is issued by the backend on login, attached to REST requests through the shared API client, and also used to authenticate the SignalR connection so real-time events are scoped to the authorized user. Role-based access control is enforced on the frontend by conditionally rendering and routing based on the user's role claims, complementing the authorization checks enforced server-side.

Interactive components were built on Radix UI primitives, which provide correct keyboard navigation and ARIA semantics by default for the complex patterns this platform relies on — multi-step approval forms, data tables, and modals — rather than needing to hand-roll accessibility behavior for each one.

• JWT-based authentication with the token attached to both REST and SignalR connections
• Role-based access control enforced on the frontend (route and UI-level) alongside backend authorization
• All contract actions — edits, approvals, access — routed through the Audit Logs module for traceability

• Large enterprise applications benefit from modular architecture and reusable design systems — the biggest maintenance wins came from resisting the urge to let each module build its own version of a table or form.
• Centralizing shared contract state early made it much easier to add new modules later without touching existing ones.