Planning Contract Renewals with SharePoint and Power Automate

The Business Situation

Elmbridge Facilities Partners is a fictional 92-person facilities services company that relies on software providers, equipment lessors, specialist subcontractors, fleet vendors, training providers, and professional advisers. The business manages approximately 140 active vendor agreements.

The procurement manager owns the contract process. A procurement coordinator maintains the records, while the finance controller, legal and compliance manager, and 18 departmental business owners contribute to reviews. An external lawyer is consulted for unusual or high-risk terms. A Microsoft 365 administrator supports SharePoint and Power Automate.

Approximately 12 contracts reach a renewal review point each month. The company also receives about eight new agreements or amendments per month. Many contracts contain automatic renewal clauses with notice periods ranging from 30 to 120 days.

The existing process used an Excel workbook, email, shared folders, calendar reminders, and DocuSign. The tools were individually useful, but ownership, notice dates, spend, performance, review tasks, negotiation status, approvals, and signed documents were not connected.

Several contracts renewed before procurement had collected usage information or confirmed whether the service was still required. Other reviews began on time but stalled because the business owner, finance reviewer, or legal reviewer did not know who was waiting for whom.

Note: This case study is provided as a representative example of the types of AI integration and digital transformation solutions Intelligex designs and delivers. Actual engagements are tailored to each client’s goals, constraints, existing systems, timeline, and available resources, so the approach, tools, and outcomes may vary.

The company needed a controlled process that started well before the contractual notice deadline, not merely before the expiration date. It also needed an evidence trail showing what was reviewed, who approved the decision, which version was signed, and what terms became effective.

The Existing Process

The original process followed this sequence:

1. A department emailed a contract or renewal notice to procurement.
2. The procurement coordinator saved the file in a general contracts folder.
3. Contract details were copied into an Excel workbook.
4. A calendar reminder was created using the contract end date or notice period.
5. When the reminder appeared, procurement emailed the business owner to ask whether the service was still needed.
6. Finance was asked to find actual spend in the accounting system.
7. Legal reviewed the contract if someone believed the terms had changed.
8. Negotiation was conducted through email and separately edited documents.
9. Approval evidence remained in email threads.
10. DocuSign was used for agreements requiring signatures.
11. The executed file was manually downloaded and saved in a shared folder.
12. The workbook was updated when someone remembered to close the item.

Manual data entry also introduced inconsistent vendor names, currencies, contract types, and dates. A supplier might appear under its legal name in the contract, a trading name in the accounting system, and an abbreviation in the renewal workbook.

The spreadsheet could show that a renewal was due, but it could not prove that all required reviews had been completed. It also did not distinguish a missing response from a deliberate decision to renew.

What the New System Needed to Do

The project team defined the requirements before configuring any automation.

The project also required a manual override. Procurement needed to reassign an owner, change a due date, reopen a completed review, or move a failed record into a controlled recovery queue without editing the automation itself.

Implementation Approaches Considered

Improved Workbook and Calendar Process

This option would have added validation lists, a standard folder structure, and more consistent calendar reminders. It was inexpensive to start, but it did not provide dependable task ownership, approval history, document synchronization, or failure monitoring.

Microsoft 365 Workflow with DocuSign

This approach retained the company’s existing identity, collaboration, storage, and e-signature tools. It could support structured lists, version history, automated date calculations, approvals, reminders, document workspaces, and signature status updates without introducing a separate business database.

No-Code Contract Database

A no-code database would provide flexible interfaces and relationships. It was not selected because contract data would move outside the existing SharePoint governance structure, and the company would need to maintain another identity, permission, backup, and licensing model.

Dedicated Contract Lifecycle Management Platform

A dedicated platform would become attractive if the business needed clause libraries, redlining, obligation management, supplier portals, advanced legal analytics, or formal records controls. At 140 active contracts and 12 monthly renewal cycles, the initial scope did not justify replacing tools the company already used.

Custom Application

A custom application offered the greatest flexibility but would require application hosting, database administration, identity integration, security testing, support procedures, and ongoing development. The workflow did not yet require that level of engineering.

The Selected Solution

Elmbridge Facilities Partners selected a Microsoft 365 workflow connected to DocuSign. The core process uses native connectors and controlled SharePoint data rather than custom application code.

Existing Microsoft 365 accounts, the procurement SharePoint site, and the DocuSign account were retained. The Excel renewal tracker stopped being the system of record after validated data was migrated.

Manual copying between email, spreadsheets, folders, and DocuSign was removed. The substantive review of usage, supplier performance, legal risk, pricing, termination, and final commercial terms remained human-controlled.

SharePoint was selected as the system of record because the company already governed access through Microsoft 365 groups. Power Automate was selected because it could connect Forms, SharePoint, Outlook, approvals, and DocuSign using the same organizational identity.

System Architecture and Data Flow

• Intake: Group-owned Microsoft Forms for contract intake and review responses
• System of record: SharePoint lists for contracts, matters, tasks, approvals, and exceptions
• Automation layer: Power Automate cloud flows
• Document storage: A versioned SharePoint contract library
• Notifications: Microsoft 365 Outlook and Power Automate approvals
• Reporting: Indexed SharePoint views and exported management summaries when required
• AI layer: Optional Azure document reading and language model extraction, subject to human verification

1. Contract submission: An authenticated employee submits the Contract Intake form and uploads the current agreement or approved draft. Microsoft Forms supplies the response identifier and respondent identity.

2. Validation: Power Automate retrieves the response, confirms required dates and owners, parses the attachment metadata, and checks whether the response identifier has already been processed.

3. Contract creation: The flow creates a SharePoint Contracts item. SharePoint returns its numeric item ID, which is used to generate a stable identifier such as CTR-2026-000142.

4. Matter creation: The flow creates an Initial Intake, Renewal, Amendment, or Termination matter. SharePoint returns the matter item ID, which becomes a value such as MAT-2026-000389.

5. Workspace creation: Power Automate creates a folder named with the contract ID and vendor name. It creates subfolders for intake, evidence, drafts, signature files, and executed documents.

6. Document transfer: The submitted file is copied from the Forms upload location to the intake folder. The destination URL is written to the contract and matter records.

7. Date calculation: The flow calculates the notice deadline, renewal review start date, decision due date, and task due dates from verified contract fields.

8. Renewal opening: A scheduled flow checks active contracts daily. When the renewal start date is reached, it creates one renewal matter for the contract cycle and prevents duplicates with a unique cycle key.

9. Review assignment: Business, finance, legal, and procurement tasks are created according to spend, risk, service criticality, and data-processing rules.

10. Decision routing: When required tasks are complete, the business owner chooses whether to renew, renegotiate, terminate, or request more information. Power Automate records the response.

11. Approval: Legal approval occurs first when required. Finance and business approvals then run in parallel. High-risk or policy-exception matters receive an additional named approver.

12. Signature: Power Automate sends the approved document through DocuSign. The returned envelope ID is stored on the matter.

13. Completion: When DocuSign reports completion, the executed file is downloaded to SharePoint, linked to the matter, and promoted as the current executed contract after verification.

14. Failure path: If any critical action fails, the matter is marked as an exception, an exception record is created, and the procurement automation owner receives a recovery link.

Data Structure

The implementation uses related SharePoint lists rather than one oversized list. One Contract can have many Matters. One Matter can have many Review Tasks and Approval Log entries. Documents carry both Contract ID and Matter ID metadata.

Contracts List

Renewal Matters List

Review Tasks, Approval Log, and Exceptions

SharePoint version history is enabled on every list and the document library. Versioning records field and document changes, but the Approval Log is still required because it provides a concise business history rather than forcing reviewers to interpret technical version records.

Workflow Statuses and Ownership

A record can move backward when a reviewer requests more information, an approver rejects the draft, a signature recipient declines, or procurement discovers that the selected document is not the approved version.

Only procurement can reopen a closed matter. Legal approval is required before a high-risk rejection or termination branch is considered complete. Automation never interprets silence as approval.

Step-by-Step Implementation

Step 1: Prepare the Accounts and Permissions

1. Create separate test and production SharePoint sites or clearly separated lists and libraries. Elmbridge used a test site named Contract Operations Test and a production site named Contract Operations.

2. Create a Microsoft 365 group for contract operations. Make the intake and review forms group-owned so continuity does not depend on one employee’s account.

3. Create security groups for Contract Administrators, Procurement Reviewers, Legal Reviewers, Finance Reviewers, and Reporting Readers. Business owners receive task or approval requests but do not automatically receive unrestricted access to all contract files.

4. Identify a Power Automate connection owner. Where organizational policy permits, use a licensed automation account such as YOUR_AUTOMATION_ACCOUNT. Add at least two flow co-owners so the process is not dependent on one person.

5. Confirm that the available Power Automate entitlement supports the required connectors, approval actions, run frequency, and environment controls. Confirm that the DocuSign account supports the selected connector or API access. Product entitlements vary, so this must be verified against current vendor documentation and the organization’s subscription.

6. Create authenticated connections for Microsoft Forms, SharePoint, Microsoft 365 Outlook, Power Automate Approvals, and DocuSign. The connection owner should have only the permissions needed to read the forms, update the contract site, send approved notifications, and create or retrieve authorized envelopes.

7. Configure the DocuSign account with an integration user or delegated connection, approved sender identity, recipient roles, standard email text, and reusable templates for standard renewal amendments. Legal must own template content and signature placement.

8. Create test users representing procurement, business, finance, legal, a delegated approver, and an unauthorized user. Use non-production email addresses or controlled test accounts.

9. If Power Platform solutions and environment variables are available, store site URLs, list names, form IDs, folder names, threshold values, and notification addresses as environment variables. Otherwise, create a restricted SharePoint Configuration list.

10. Never store API keys or passwords in a visible list, Compose action, email, or exported flow screenshot. Mark sensitive HTTP action inputs and outputs as secure when optional AI services are added.

The production account requires permission to create list items and folders, copy files, update metadata, and read completed documents. It does not need site collection administrator access for routine execution.

Step 2: Build the Intake

Create two group-owned Microsoft Forms: Contract Intake and Contract Review Response. Restrict both forms to authenticated organizational users because file-upload questions require controlled storage and because the workflow relies on verified respondent identity.

Use Forms branching so renewal-term questions appear only when automatic renewal is Yes or Uncertain. Unknown notice periods and risk tiers are valid intake answers, but they force an Intake Review status rather than being treated as zero or low risk.

The confirmation message should explain that submission does not approve a contract. It should tell the requester that procurement will verify the record and provide a matter identifier.

Add a concise privacy notice explaining that contract documents and business contact details will be stored in the controlled contract workspace. Instruct users not to upload bank credentials, authentication secrets, personal identity documents, or unrelated sensitive material.

The Contract Review Response form captures:

• Contract ID and Matter ID
• Review type: Business, Finance, Legal, or Procurement
• Is the service still required?
• Approximate utilization percentage
• Performance score from 1 to 5
• Known service issues
• Verified annual spend
• Budget availability
• Known alternative suppliers
• Recommended decision
• Comments and evidence attachment

The flow compares the authenticated respondent’s email with the task assignee or approved delegate. A valid matter ID alone is not sufficient authorization.

Forms blocks omitted required answers before submission. The flow still validates dates, numbers, ownership, and attachments because client-side validation does not protect against every configuration change or integration issue.

Step 3: Create the System of Record

Create these SharePoint objects:

• Contracts list
• Renewal Matters list
• Review Tasks list
• Approval Log list
• Automation Exceptions list
• Configuration list, if environment variables are not available
• Contract Documents library

Create SharePoint columns using stable internal names such as ContractID, CurrentEndDate, and AutomationStatus. If friendlier display labels are needed, create the concise internal name first and then change the display label.

Enable unique-value enforcement on:

• Contracts.SourceSubmissionKey
• Contracts.ContractID
• Renewal Matters.MatterID
• Renewal Matters.MatterCycleKey
• Review Tasks.TaskKey
• Approval Log.ApprovalKey

Enable version history. Index the fields used most often by filters:

• Contracts.ContractID
• Contracts.ContractStatus
• Contracts.RenewalStartDate
• Contracts.CurrentEndDate
• Contracts.BusinessOwner
• Renewal Matters.MatterCycleKey
• Renewal Matters.Status
• Renewal Matters.DecisionDueDate
• Renewal Matters.DocuSignEnvelopeID
• Review Tasks.AssignedTo
• Review Tasks.Status
• Review Tasks.DueDate
• Automation Exceptions.ResolutionStatus

Use stored date fields rather than calculating every deadline at report time. Stored values are easier to filter and allow the automation to preserve the date calculation that applied to a particular contract cycle.

When a Contracts item is first created, SharePoint assigns a numeric ID. Power Automate then updates the item with a formatted ContractID. The same pattern is used for MatterID.

Create filtered views for active contracts, renewals starting in 180 days, open matters, overdue tasks, decision required, negotiation in progress, awaiting signature, completed this month, and automation exceptions.

Step 4: Connect the Tools

The Forms connection reads the response and attachment metadata. File storage differs depending on whether a form is personally owned or group-owned. For a group-owned form, confirm the generated SharePoint upload path with a test submission, then store that base path in configuration.

The DocuSign connection uses delegated OAuth through the connector. Do not place a DocuSign password in the flow. If the connector version exposes different action labels, configure the equivalent sequence: create an envelope from an approved template or document, map recipients, send it, capture the envelope ID, monitor status, and retrieve completed documents.

For standard renewal letters, DocuSign templates define recipient roles and signature fields. For negotiated long-form documents, legal must verify that the uploaded final PDF contains or receives the correct signature tabs before it is sent.

Step 5: Build the Core Automation

Flow F01: Contract Intake and Workspace Creation

• Trigger: Microsoft Forms reports a new Contract Intake response.
• Conditions: Response has not already been processed; required values are present; dates and numeric fields are valid.
• Actions: Retrieve response, validate, create contract, generate ID, create matter, create folders, copy attachments, update links, and notify procurement.
• Fields updated: ContractID, MatterID, date fields, owners, document URLs, status, and automation timestamps.
• Notification: Confirmation to requester and intake task to procurement.
• Exception: Create an Automation Exceptions record and set AutomationStatus to Manual Review.

The exact action order is:

1. Initialize CorrelationID with the Power Automate run name.
2. Get response details.
3. Build SourceSubmissionKey from the form identifier and response identifier.
4. Check the Contracts list for the key.
5. If found, terminate as Succeeded with a duplicate-event log entry.
6. Validate vendor name, owner email, effective date, end date, spend, and attachment.
7. Create the Contracts item with AutomationStatus set to Processing.
8. Generate and write ContractID.
9. Create the Renewal Matters item with MatterType from the intake response.
10. Generate and write MatterID and MatterCycleKey.
11. Create the contract folder and five standard subfolders.
12. Copy each submitted document to the intake folder.
13. Write ContractID, MatterID, and DocumentType metadata to each copied file.
14. Calculate NoticeDeadline, RenewalStartDate, and DecisionDueDate.
15. Update the contract and matter records with URLs and dates.
16. Set the matter to Intake Review and AutomationStatus to Complete.
17. Send a confirmation containing ContractID and MatterID.

Potential business duplicates are not automatically deleted. The flow compares normalized vendor name, contract number, contract type, and end date. If a similar record exists, it flags the matter for procurement review while preserving the submitted evidence.

Flow F02: Daily Renewal Scheduler

• Trigger: Recurrence every weekday before business hours.
• Conditions: Contract is Active, RenewalStartDate is today or earlier, CurrentEndDate is in the future, and no matching MatterCycleKey exists.
• Actions: Create renewal matter, calculate priority, create required tasks, update LatestMatterID, and send assignments.
• Fields updated: MatterID, status, cycle key, priority, task due dates, and contract LatestMatterID.
• Notification: Review-opening summary to procurement and assigned reviewers.
• Exception: Mark the affected contract for Manual Review if task or matter creation is incomplete.

The cycle key uses the contract ID, matter type, and cycle end date, for example CTR-2026-000142|RENEWAL|2026-12-31. The SharePoint uniqueness constraint prevents two scheduled runs from opening the same cycle.

Task assignment rules are read from configuration rather than hard-coded into every condition. A typical matter receives Business Usage, Vendor Performance, Finance Spend, and Procurement Market Check tasks. Legal Terms Review is added when any of the following is true:

• Risk tier is Medium or High.
• The contract processes personal data.
• The service is Critical.
• The notice period is uncertain.
• The proposed terms differ from the approved template.
• Annual spend meets the legal-review threshold.

Flow F03: Review Response Processing

• Trigger: New Contract Review Response form submission.
• Conditions: Matter and task exist; respondent is assignee or approved delegate; task is not already completed.
• Actions: Validate score and spend values, save evidence, update task, and evaluate remaining tasks.
• Fields updated: Review response, score, status, completed by, completed date, and evidence URL.
• Notification: Completion acknowledgement and notice to procurement if all tasks are complete.
• Exception: Unauthorized or unmatched responses enter the manual-review queue.

If every required task is Complete, the matter moves to Decision Required. If a reviewer selects More Information Required, the task remains open and procurement receives the comments.

Flow F04: Decision and Negotiation Routing

• Trigger: Business decision is submitted through an approval response or controlled matter update.
• Conditions: All required reviews are complete and respondent is the authorized decision owner.
• Actions: Record decision, create approval log entry, and route to renewal, negotiation, or termination branch.
• Fields updated: Decision, DecisionRationale, Status, NegotiationStatus, and ApprovalStatus.
• Notification: Branch-specific notice to procurement, legal, finance, and business owner.
• Exception: Conflicting or incomplete responses return the matter to Decision Required.

A Renew decision can proceed to approval with the existing terms or a standard renewal amendment. A Renegotiate decision moves to Negotiation. A Terminate decision creates a controlled termination task and requires confirmation that contractual notice can still be delivered on time.

Flow F05: Final Draft Approval

• Trigger: ApprovalReady becomes true while ApprovalStarted is false.
• Conditions: Draft document exists, all required reviews are complete, recipients are valid, and no unresolved exception exists.
• Actions: Set ApprovalStarted, perform legal approval when required, run finance and business approvals in parallel, log responses, and calculate final outcome.
• Fields updated: ApprovalStarted, ApprovalStatus, Status, and approval timestamps.
• Notification: Approval request and final outcome notice.
• Exception: Rejection returns the matter to Negotiation; timeout or unavailable approver enters escalation.

Flow F06: DocuSign Dispatch

• Trigger: Matter ApprovalStatus becomes Approved and DocuSignEnvelopeID is empty.
• Conditions: Approved draft exists; vendor and internal signer details are verified; signature is required.
• Actions: Retrieve file, create or send envelope, map recipient roles, capture envelope ID, and update matter.
• Fields updated: DocuSignEnvelopeID, DocuSignStatus, Status, LastAutomationRun, and AutomationStatus.
• Notification: Dispatch confirmation to procurement and the business owner.
• Exception: Failed dispatch sets Signature exception and preserves the approved draft.

Before creating an envelope, the flow writes an EnvelopeRequestKey such as MAT-2026-000389|FINAL|1. If a retry occurs and an envelope ID already exists, the flow checks that envelope instead of sending a second one.

Flow F07: DocuSign Completion and Archiving

• Trigger: DocuSign envelope status changes, supplemented by scheduled reconciliation.
• Conditions: Envelope ID matches one matter and completed file has not already been archived.
• Actions: Retrieve completed document, store it in Executed, save signing evidence when available, update current terms, and close the matter.
• Fields updated: ExecutedDocumentUrl, DocuSignStatus, Status, contract dates, CurrentExecutedDocumentUrl, and AutomationStatus.
• Notification: Completion notice to procurement, legal, finance, business owner, and requester as appropriate.
• Exception: A completed envelope without a retrievable file is marked as a Document exception and reconciled later.

The flow does not update the next contract end date from an unverified AI result. Procurement confirms the final dates and notice terms from the executed document before the contract returns to Active.

Step 6: Add Approvals, Reminders, and Escalations

The approval path is driven by configurable rules:

• Low-risk renewals below the financial threshold can use parallel business and finance approval.
• Medium-risk, personal-data, nonstandard, or renegotiated agreements require legal approval first.
• After legal approval, business and finance approvals run in parallel.
• High-risk or policy-exception matters require an additional named executive or compliance approver.
• Termination and non-renewal decisions require business owner and procurement approval, plus legal confirmation when notice wording or timing is disputed.

Place approval actions inside named scopes:

1. Scope: Validate Approval Package
2. Scope: Legal Approval
3. Scope: Parallel Business and Finance Approval
4. Scope: Consolidate Outcome
5. Scope: Catch Failure
6. Scope: Final Status Update

Configure Catch Failure to run after failure or timeout of any critical approval scope. Configure Final Status Update to run regardless of success so LastAutomationRun and the final correlation ID are recorded.

Every approval request includes:

• Contract ID and Matter ID
• Vendor and contract title
• Current end date and notice deadline
• Verified annual spend and risk tier
• Business, finance, and legal review summaries
• Decision and rationale
• Approved draft link
• Required response date
• Clear options to approve, reject, or request more information

Reminder timing is implemented with a weekday recurrence flow. It retrieves open tasks and approvals whose NextReminderDate is today or earlier. After sending a reminder, the flow increments ReminderCount and calculates the next date.

If an approver is unavailable, procurement can set a DelegatedApprover field. The flow records both the original approver and the delegate. Delegation does not permit a user to approve their own request when segregation-of-duties policy prohibits it.

A rejection changes ApprovalStatus to Rejected and returns the matter to Negotiation. A request for more information changes ApprovalStatus to More Information and reopens the relevant review task. Neither response sends a document to DocuSign.

Step 7: Add Documents and File Management

Create one top-level folder for each contract:

CTR-2026-000142 - Blue Cedar Scheduling
    01 Intake
    02 Review Evidence
    03 Drafts
    04 Signature
    05 Executed

Use file names that remain meaningful outside SharePoint:

CTR-2026-000142_MAT-2026-000389_RenewalDraft_v03_2026-08-18.pdf
CTR-2026-000142_MAT-2026-000389_Executed_2026-09-14.pdf
CTR-2026-000142_MAT-2026-000389_SigningCertificate_2026-09-14.pdf

Store ContractID, MatterID, DocumentType, VersionStatus, EffectiveDate, and VendorLegalName as library metadata. File names help people, while metadata supports views and automation.

Enable document versioning. Drafts can be replaced only by uploading a new version or a distinctly numbered file. The flow must not overwrite a file marked Executed.

The final approved draft is selected through DraftDocumentUrl. The signature flow retrieves that exact file rather than choosing the newest file in the folder.

Restrict the library to the contract operations group by default. If business owners need evidence access, grant access to the specific folder or document required for their review. Avoid organization-wide sharing links.

If an attachment exceeds the configured operational size or uses an unsupported format, the matter enters Manual Review. The configured threshold should be based on the organization’s connector, storage, email, and security constraints rather than an assumed universal platform limit.

Retention and archiving rules must align with the company’s legal and records policy. SharePoint versioning improves recoverability but is not a substitute for a formal retention policy where one is required.

Step 8: Add Reporting and Operational Views

SharePoint views refresh when list data changes. For monthly management reporting, Power Automate can create a scheduled summary email containing counts by status, overdue task count, notice deadlines at risk, signature exceptions, and matters closed during the month.

The procurement manager owns dashboard definitions. Alert thresholds are stored in configuration, including the number of days before a notice deadline that changes a matter from Normal to High or Critical priority.

Step 9: Add Security and Governance Controls

• Least privilege: Separate site owners, list contributors, reviewers, and reporting readers.
• Role-based access: Legal and procurement can access all contract records; finance receives the financial records and documents needed for review; business owners receive matter-specific requests.
• Sensitive fields: Avoid storing bank details, passwords, personal identity documents, or authentication secrets in Forms or SharePoint.
• Sharing controls: Disable anonymous links for contract workspaces and restrict external sharing to approved processes.
• Credential storage: Use connector-managed OAuth, protected environment variables, a secret-management service, or secured custom connectors where appropriate.
• Activity evidence: Retain SharePoint version history, flow run identifiers, approval logs, and DocuSign envelope IDs.
• Former employees: Remove access, reassign open tasks, and replace flow connections before disabling an account that owns integrations.
• Backups: Confirm the organization’s SharePoint recovery and retention capabilities. Periodically test restoration procedures.
• Privacy: Limit contract data to a justified purpose and apply regional or regulatory controls appropriate to the organization.
• AI restrictions: Do not send privileged, export-controlled, highly sensitive, or prohibited data to an AI service without an approved data-handling basis.
• Human approval: Require human confirmation for legal terms, spend, termination, policy exceptions, and final contract dates.

For highly confidential contracts, use a separate restricted library or site rather than relying on broad inherited permissions. Large numbers of unique item permissions can become difficult to administer and should be designed deliberately.

Step 10: Deploy and Test

1. Create the lists, forms, folders, templates, and flows in the test environment.
2. Load at least 20 synthetic contracts covering low, medium, and high-risk paths.
3. Test dates close to notice deadlines as well as dates more than a year away.
4. Use test accounts for procurement, business, finance, legal, delegation, and unauthorized access.
5. Run technical tests before user acceptance testing.
6. Conduct user acceptance testing with one procurement coordinator, two business owners, one finance reviewer, and one legal reviewer.
7. Pilot the system with 15 to 20 active contracts and at least three live renewal cycles that can safely be handled in parallel with the old process.
8. Reconcile every pilot record against source documents before making SharePoint authoritative.
9. Activate scheduled flows only after idempotency and duplicate-event tests pass.
10. Migrate active contract data in batches, preserving a migration source identifier.
11. Keep the old workbook read-only for an agreed validation period.
12. Publish a short user guide, owner guide, recovery runbook, and data dictionary.
13. Assign a launch support owner and backup owner.
14. Monitor all flow runs daily during the first two weeks.
15. If rollback is required, disable triggers, preserve submitted records, and return to the documented contingency process. Do not delete partially processed matters.

Code and Configuration

The core implementation does not require a custom script. Microsoft Forms, SharePoint, Power Automate, Outlook, approvals, and DocuSign provide the required triggers and actions. The configuration below supplies the expressions, schemas, and controls needed to reproduce the flows.

Configuration Values

Store these values as Power Platform environment variables or in a restricted configuration list:

CONTRACT_SITE_URL=https://YOUR_TENANT.sharepoint.com/sites/YOUR_CONTRACT_SITE
CONTRACTS_LIST=Contracts
MATTERS_LIST=Renewal Matters
TASKS_LIST=Review Tasks
APPROVAL_LOG_LIST=Approval Log
EXCEPTIONS_LIST=Automation Exceptions
DOCUMENT_LIBRARY=Contract Documents
CONTRACT_INTAKE_FORM_ID=YOUR_CONTRACT_INTAKE_FORM_ID
REVIEW_FORM_ID=YOUR_REVIEW_FORM_ID
FORMS_UPLOAD_BASE_PATH=YOUR_CONFIRMED_FORMS_UPLOAD_PATH
PROCUREMENT_EMAIL=YOUR_EMAIL_ADDRESS
AUTOMATION_SUPPORT_EMAIL=YOUR_EMAIL_ADDRESS
DEFAULT_REVIEW_LEAD_DAYS=120
DEFAULT_DECISION_BUFFER_DAYS=30
FINANCE_APPROVAL_THRESHOLD=50000
HIGH_PRIORITY_NOTICE_DAYS=30

The financial threshold is an example policy assumption for this representative scenario, not a universal recommendation.

Power Automate Expressions

Use the run name as a correlation identifier:

workflow()?['run']?['name']

Create a unique source submission key:

concat('FORM|', variables('ContractIntakeFormID'), '|', string(triggerOutputs()?['body/resourceData/responseId']))

If the Forms trigger exposes the response ID through a different dynamic field, insert that field using dynamic content rather than typing an unverified property path.

Normalize the vendor name:

toUpper(trim(outputs('Get_response_details')?['body/YOUR_VENDOR_NAME_FIELD']))

Generate a contract identifier after the SharePoint item is created:

concat('CTR-', formatDateTime(utcNow(),'yyyy'), '-', formatNumber(outputs('Create_contract')?['body/ID'],'000000'))

Generate the matter identifier:

concat('MAT-', formatDateTime(utcNow(),'yyyy'), '-', formatNumber(outputs('Create_matter')?['body/ID'],'000000'))

Create a renewal cycle key:

concat(
  outputs('Compose_ContractID'),
  '|RENEWAL|',
  formatDateTime(items('For_each_contract')?['CurrentEndDate'],'yyyy-MM-dd')
)

Calculate the notice deadline:

addDays(
  items('For_each_contract')?['CurrentEndDate'],
  mul(-1, int(items('For_each_contract')?['NoticePeriodDays']))
)

Calculate the renewal start date:

addDays(
  outputs('Compose_NoticeDeadline'),
  mul(-1, int(items('For_each_contract')?['ReviewLeadDays']))
)

Calculate the decision due date:

addDays(
  outputs('Compose_NoticeDeadline'),
  mul(-1, variables('DecisionBufferDays'))
)

Build a SharePoint filter for active contracts whose review date has arrived:

concat(
  'ContractStatus eq ''Active'' and RenewalStartDate le ''',
  formatDateTime(utcNow(),'yyyy-MM-ddTHH:mm:ssZ'),
  ''''
)

Use this trigger condition on the final approval flow:

@and(
  equals(triggerBody()?['ApprovalReady'], true),
  equals(triggerBody()?['ApprovalStarted'], false)
)

Use this condition before creating a DocuSign envelope:

@and(
  equals(triggerBody()?['ApprovalStatus']?['Value'], 'Approved'),
  empty(triggerBody()?['DocuSignEnvelopeID']),
  not(empty(triggerBody()?['DraftDocumentUrl']))
)

SharePoint choice-field output shapes can differ between connector actions. Use the dynamic token produced by the action and inspect a test run before finalizing a property path.

Forms Attachment Parsing

The file-upload answer is commonly returned as a JSON array encoded as text. Check for an empty value before using Parse JSON. Use a schema based on an actual test response. This minimal schema accepts the fields required by the flow:

{
  "type": "array",
  "items": {
    "type": "object",
    "properties": {
      "name": {
        "type": "string"
      },
      "link": {
        "type": "string"
      },
      "id": {
        "type": "string"
      },
      "driveId": {
        "type": [
          "string",
          "null"
        ]
      },
      "size": {
        "type": [
          "integer",
          "null"
        ]
      }
    },
    "required": [
      "name",
      "id"
    ]
  }
}

After parsing, loop through the array. Retrieve each file from the confirmed Forms upload location, create it in 01 Intake, and update its SharePoint metadata. If the form’s ownership or storage location changes, test and update the configured source path before enabling production submissions.

Try, Catch, and Finalize Scopes

Every business-critical flow uses this pattern:

1. Try: Contains validation, record updates, file actions, approvals, or signature actions.
2. Catch: Configured to run after Try fails or times out. It creates an exception record and updates AutomationStatus to Failed.
3. Finalize: Configured to run after Try or Catch. It records LastAutomationRun and the correlation ID.

For transient connector actions, configure an exponential retry policy with a conservative number of attempts. Elmbridge used four attempts for retry-safe read, create, and update operations. Do not automatically retry an envelope-send action unless the EnvelopeRequestKey and existing envelope lookup prove that a duplicate will not be created.

Approval Result Consolidation

After the parallel business and finance branches complete, use a condition equivalent to:

@and(
  equals(variables('BusinessOutcome'), 'Approve'),
  equals(variables('FinanceOutcome'), 'Approve'),
  or(
    equals(variables('LegalRequired'), false),
    equals(variables('LegalOutcome'), 'Approve')
  )
)

If true, update ApprovalStatus to Approved. If any outcome is Reject, update it to Rejected. If any outcome requests more information, update it to More Information and reopen the appropriate review task.

DocuSign Native Configuration

Configure the signature flow in this order:

1. Get the Renewal Matters item.
2. Verify that DocuSignEnvelopeID is empty.
3. Get the approved draft file content from DraftDocumentUrl.
4. Resolve vendor signer name and email from verified matter fields.
5. Resolve internal signer from the approval policy.
6. Use the DocuSign connector action that creates an envelope from the approved template or document.
7. Map the vendor and internal signers to the correct recipient roles and routing order.
8. Set the email subject to include MatterID but not sensitive contract terms.
9. Send the envelope.
10. Capture the returned envelope ID.
11. Update DocuSignEnvelopeID, DocuSignStatus, Status, and EnvelopeRequestKey.
12. Write a dispatch event to the Approval Log or a dedicated integration log.

Connector labels can vary by version. The required behavior is create, map recipients, send, capture the envelope ID, monitor status, and retrieve completed files.

Use a DocuSign status-change trigger when supported. Also run a scheduled reconciliation that queries open envelope IDs. The reconciliation closes the gap if a webhook or connector event is missed.

Failure Handling and Operational Reliability

The Automation Exceptions list acts as a dead-letter queue. It contains records that could not safely continue, including the flow name, run ID, matter ID, failed stage, retry count, sanitized message, owner, and resolution notes.

Idempotency is enforced through unique keys and state checks. A flow checks whether the expected destination record, folder, task, approval, or envelope already exists before repeating a create action.

A daily reconciliation compares:

• Active contracts whose renewal start date has passed against open renewal matters
• Open matters against required task counts
• Approved matters against DocuSign envelope IDs
• Completed envelopes against executed SharePoint files
• Closed matters against final contract dates and document links

Staff recover a failed record by opening the exception, correcting the source data or connection, setting ResolutionStatus to Ready for Retry, and running a controlled recovery flow. The recovery flow processes one identified contract or matter rather than replaying every historical event.

A Complete Example

Blue Cedar Scheduling Ltd. is a fictional software vendor used by Elmbridge Facilities Partners for workforce scheduling.

The current agreement has an annual value of $48,000, an end date of December 31, 2026, a 90-day notice period, and a 12-month automatic renewal term. The business owner is the operations systems manager. The contract processes employee scheduling information, so legal review is required.

1. An employee submits the Contract Intake form with the current PDF. Microsoft Forms returns response ID 1842.

2. Power Automate creates the submission key FORM|YOUR_CONTRACT_INTAKE_FORM_ID|1842 and confirms that it is new.

3. SharePoint creates contract item 142. The flow assigns CTR-2026-000142.

4. The initial matter item receives MAT-2026-000389. The document is copied into the contract’s Intake folder.

5. The notice deadline is calculated as October 2, 2026. With a 120-day review lead, the renewal start date is June 4, 2026. The decision due date is September 2, 2026.

6. On June 4, the renewal scheduler creates a renewal matter using cycle key CTR-2026-000142|RENEWAL|2026-12-31.

7. Business Usage, Vendor Performance, Finance Spend, Procurement Market Check, and Legal Terms Review tasks are created.

8. The business review reports 62 percent utilization and a performance score of 3.8 out of 5. Finance verifies $48,000 annual spend. Procurement records that two alternative products are available.

9. Legal confirms the 90-day notice clause, automatic renewal, data-processing terms, and governing-law clause.

10. After all tasks are complete, the business owner selects Renegotiate and explains that unused licenses should be removed.

11. Procurement negotiates a lower seat count and uploads the final renewal amendment to the Drafts folder. ApprovalReady is set to true.

12. Legal approves first. Business and finance approvals then run in parallel. Their approval IDs, comments, and timestamps are copied to the Approval Log.

13. Power Automate sends the approved amendment through DocuSign and stores example envelope ID 11111111-2222-4333-8444-555555555555.

14. DocuSign reports Completed. The executed PDF is downloaded as CTR-2026-000142_MAT-2026-000389_Executed_2026-09-14.pdf.

15. Procurement verifies the new annual amount, term, notice period, and end date from the executed agreement. The Contracts item is updated, the matter is closed, and all participants receive the completion notice.

If the DocuSign completion event had arrived twice, the second run would have found the existing executed-document URL and ended without creating another file.

Implementation Cost

All amounts below are representative planning assumptions for this fictional scenario. They are not vendor price quotations or verified client costs. Current subscription, connector, envelope, storage, regional, and implementation prices must be confirmed directly for each deployment.

Estimated Time and Cost Savings

The calculation covers 12 monthly renewal cycles. It measures administrative coordination, data handling, reminders, status updates, and document transfer. It excludes substantive negotiation and legal analysis that still need to occur.

Current monthly labour hours: Monthly volume × current minutes per record ÷ 60

12 × 150 ÷ 60 = 30.00 hours

New monthly labour hours: Monthly volume × new minutes per record ÷ 60, plus exception handling and maintenance

Core handling: 12 × 45 ÷ 60 = 9.00 hours
Exception handling: 12 × 15% × 25 ÷ 60 = 0.75 hours
Maintenance: 4.00 hours
Total new labour: 9.00 + 0.75 + 4.00 = 13.75 hours

Monthly hours recovered: Current monthly labour hours minus new monthly labour hours

30.00 - 13.75 = 16.25 hours

Estimated monthly labour value: Monthly hours recovered × loaded hourly labour cost

16.25 × $58 = $942.50

Net estimated monthly value: Monthly labour value minus recurring tool costs

$942.50 - $90.00 = $852.50

Estimated payback period: One-time implementation cost ÷ net estimated monthly value

$10,050 ÷ $852.50 = 11.79 months

Recovered time does not automatically reduce payroll. It can represent additional capacity, quicker turnaround, less overtime, fewer administrative tasks, more time for negotiation, and lower dependency on one coordinator.

Non-financial benefits include:

• Fewer contracts reaching renewal without a recorded decision
• Clearer ownership and escalation
• Fewer repeated requests for spend and usage data
• Consistent separation of drafts and executed files
• Improved approval and signature evidence
• More reliable reporting on upcoming commitments
• Faster identification of incomplete or failed matters
• A more consistent experience for business owners and vendors

Readers should replace the monthly volume, handling times, exception rate, labour rate, maintenance effort, software allowance, and implementation cost with their own measured figures.

Adding AI to the Automation

AI is an optional enhancement added only after the rule-based contract workflow is stable. The core automation already creates records, calculates dates, assigns tasks, sends reminders, records approvals, transfers documents, and monitors signatures.

Useful AI applications for contract renewal planning include:

• Extracting candidate dates, parties, notice periods, and renewal clauses from contract text
• Summarizing long termination and renewal sections
• Identifying potentially missing metadata
• Classifying contract type for reviewer confirmation
• Highlighting conflicting dates or renewal language
• Comparing a draft against an executed version
• Suggesting search terms for similar contracts

AI should not be used for exact date arithmetic, approval thresholds, owner permissions, duplicate submission keys, status rules, or final legal decisions. Those tasks are better handled by required fields, formulas, lookups, validation, and human authority.

The Recommended AI Enhancement

The recommended enhancement extracts proposed contract metadata at intake. The output is placed in a review queue and does not overwrite verified contract fields.

• Trigger: A supported contract file is copied into the Intake folder and AI processing is permitted for the document.
• AI input: Text extracted from the contract, MatterID, ContractID, and a list of required fields.
• System instruction: Extract only evidence present in the document and return structured JSON.
• Expected output: Proposed values, confidence, exact evidence quotations, page references, conflicts, and missing fields.
• Validation: JSON schema validation, allowed field names, date format checks, confidence range checks, and evidence review.
• Record update: Write proposed values to AI-specific fields or an Extraction Review list.
• Human review: Procurement or legal accepts, corrects, or rejects every proposed value.
• Low confidence: Any value below 0.85 remains unverified and is highlighted.
• Failure behavior: Route to manual extraction without blocking the core contract intake.

Reusable System Instruction

You are a contract metadata extraction assistant.

Use only the supplied contract text. Do not infer a value that is not supported by the text. Do not provide legal advice or make a renewal, termination, risk, or approval decision.

Return only valid JSON matching the requested schema.

For every extracted field:
1. Preserve the exact meaning of the contract.
2. Use null when the value is absent or ambiguous.
3. Provide a short exact evidence quote.
4. Provide the page number when a page marker is available.
5. Provide a confidence value from 0 to 1.
6. Record conflicting clauses in the conflicts array.

Normalize dates as YYYY-MM-DD only when the date is unambiguous.
Normalize monetary values as numbers without currency symbols.
Do not calculate a final notice deadline. Extract the source end date and notice period so deterministic automation can calculate it.

Never treat silence, missing text, or a low-confidence result as confirmation.

Reusable User Prompt

Matter ID: {{MATTER_ID}}
Contract ID: {{CONTRACT_ID}}

Extract these fields:
vendor_legal_name
customer_legal_name
effective_date
expiration_date
automatic_renewal
renewal_term_months
notice_period_days
notice_method
notice_address
annual_fee
currency_code
payment_frequency
termination_for_convenience
governing_law
liability_cap
data_processing_clause_present
vendor_signer_name
customer_signer_name

Contract text begins below.

{{CONTRACT_TEXT}}

Return only the required JSON object.

Structured Output Schema

{
  "type": "object",
  "additionalProperties": false,
  "properties": {
    "matter_id": {
      "type": "string"
    },
    "contract_id": {
      "type": "string"
    },
    "document_class": {
      "type": [
        "string",
        "null"
      ]
    },
    "fields": {
      "type": "array",
      "items": {
        "type": "object",
        "additionalProperties": false,
        "properties": {
          "field_name": {
            "type": "string"
          },
          "value": {
            "type": [
              "string",
              "number",
              "boolean",
              "null"
            ]
          },
          "normalized_value": {
            "type": [
              "string",
              "number",
              "boolean",
              "null"
            ]
          },
          "confidence": {
            "type": "number",
            "minimum": 0,
            "maximum": 1
          },
          "evidence_quote": {
            "type": [
              "string",
              "null"
            ]
          },
          "page": {
            "type": [
              "integer",
              "null"
            ]
          }
        },
        "required": [
          "field_name",
          "value",
          "normalized_value",
          "confidence",
          "evidence_quote",
          "page"
        ]
      }
    },
    "conflicts": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "missing_required_fields": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "required": [
    "matter_id",
    "contract_id",
    "document_class",
    "fields",
    "conflicts",
    "missing_required_fields"
  ]
}

Optional Power Automate AI Configuration

One technically coherent implementation uses Azure AI Document Intelligence for text extraction and Azure OpenAI for structured metadata extraction.

1. Trigger when a file is created in the Intake folder.
2. Check that AI processing is enabled for the matter and document classification.
3. Get the SharePoint file content.
4. Send the binary document to the provisioned document-reading service.
5. Read the returned operation location.
6. Poll the operation until it succeeds, fails, or reaches the configured timeout.
7. Extract the returned document text.
8. Reject or manually route documents beyond the project’s configured processing size.
9. Send the system instruction, user prompt, and output schema to an approved language-model deployment.
10. Parse the JSON response.
11. Validate field names, confidence, data types, and evidence.
12. Create an Extraction Review record.
13. Notify the assigned human reviewer.

A representative Azure document-reading request uses this pattern. Confirm the API version supported by the provisioned resource before deployment:

Method: POST
URI: https://YOUR_DOCUMENT_INTELLIGENCE_RESOURCE.cognitiveservices.azure.com/documentintelligence/documentModels/prebuilt-layout:analyze?api-version=YOUR_SUPPORTED_API_VERSION
Headers:
  Ocp-Apim-Subscription-Key: YOUR_API_KEY
  Content-Type: application/pdf
Body:
  SharePoint file content

The initial response is asynchronous and includes an operation URL. Poll that URL with a GET request until the status is succeeded or failed. Use a delay between requests and stop after the configured timeout.

A representative Azure OpenAI request pattern is:

Method: POST
URI: https://YOUR_RESOURCE_NAME.openai.azure.com/openai/deployments/YOUR_DEPLOYMENT_NAME/chat/completions?api-version=YOUR_SUPPORTED_API_VERSION
Headers:
  api-key: YOUR_API_KEY
  Content-Type: application/json

The request body uses the approved deployment’s structured-output format. A deployment that does not support strict structured output must use JSON mode followed by the same schema validation and manual fallback.

{
  "messages": [
    {
      "role": "system",
      "content": "YOUR_SYSTEM_INSTRUCTION"
    },
    {
      "role": "user",
      "content": "Matter ID: MAT-2026-000389\nContract ID: CTR-2026-000142\n\nYOUR_CONTRACT_TEXT"
    }
  ],
  "temperature": 0,
  "response_format": {
    "type": "json_schema",
    "json_schema": {
      "name": "contract_metadata",
      "strict": true,
      "schema": {
        "type": "object",
        "additionalProperties": false,
        "properties": {
          "matter_id": {
            "type": "string"
          },
          "contract_id": {
            "type": "string"
          },
          "document_class": {
            "type": [
              "string",
              "null"
            ]
          },
          "fields": {
            "type": "array",
            "items": {
              "type": "object",
              "additionalProperties": false,
              "properties": {
                "field_name": {
                  "type": "string"
                },
                "value": {
                  "type": [
                    "string",
                    "number",
                    "boolean",
                    "null"
                  ]
                },
                "normalized_value": {
                  "type": [
                    "string",
                    "number",
                    "boolean",
                    "null"
                  ]
                },
                "confidence": {
                  "type": "number"
                },
                "evidence_quote": {
                  "type": [
                    "string",
                    "null"
                  ]
                },
                "page": {
                  "type": [
                    "integer",
                    "null"
                  ]
                }
              },
              "required": [
                "field_name",
                "value",
                "normalized_value",
                "confidence",
                "evidence_quote",
                "page"
              ]
            }
          },
          "conflicts": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "missing_required_fields": {
            "type": "array",
            "items": {
              "type": "string"
            }
          }
        },
        "required": [
          "matter_id",
          "contract_id",
          "document_class",
          "fields",
          "conflicts",
          "missing_required_fields"
        ]
      }
    }
  }
}

Secure the inputs and outputs of actions containing contract text or API credentials. Prefer a secured custom connector, managed secret approach, or approved credential store over placing keys directly in editable flow actions.

Prohibited documents are routed directly to manual review. AI requests and responses are logged by matter ID, model deployment, timestamp, processing status, and approximate usage, but sensitive contract text is not copied into general error notifications.

Benefits of the AI Enhancement

The AI enhancement can reduce the time required to locate and transcribe renewal clauses, dates, notice periods, parties, and payment terms. Evidence quotations make verification faster than receiving a value without context.

AI-specific benefits include:

• Less manual reading for routine metadata extraction
• More consistent candidate field names
• Faster identification of missing or conflicting terms
• Better handling of unstructured contract language
• Evidence references that support human verification
• Potentially faster loading of historical contracts

These benefits are separate from the core automation. Scheduling, ownership, reminders, approval routing, status reporting, DocuSign dispatch, and document archiving do not depend on AI.

What Remains Rule-Based or Human-Controlled

Estimating the Additional Value of AI

Elmbridge receives approximately 20 eligible contract documents per month when 12 renewal cycles and eight new or amended agreements are combined.

Without AI:
20 × 18 minutes = 360 minutes

With AI:
18 successful documents × 6 minutes verification = 108 minutes
18 successful documents × 20% corrections × 4 minutes = 14.4 minutes
2 failed documents × 18 minutes manual fallback = 36 minutes
Monthly quality sampling = 30 minutes

Total with AI:
108 + 14.4 + 36 + 30 = 188.4 minutes

Additional capacity:
360 - 188.4 = 171.6 minutes
171.6 ÷ 60 = 2.86 hours

Estimated labour value:
2.86 × $58 = $165.88

Net after AI usage allowance:
$165.88 - $45 = $120.88 per month

These assumptions do not claim that AI eliminates errors. Every extracted term remains subject to human verification. At this volume, the financial case is modest, so the strongest reasons to add AI may be faster historical loading, evidence consistency, or future document growth.

Testing Checklist

Use synthetic sample data and test documents before processing real contract information.

Ongoing Maintenance

The procurement manager is the primary business owner. The Microsoft 365 administrator is the technical owner. A second administrator is designated as backup.

Credential rotation and connection renewal follow the organization’s security policy. Any account scheduled for deactivation must first have its flow ownership, connections, open approvals, and assigned tasks reviewed.

Documentation should include the data dictionary, list configuration, environment variables, assignment rules, flow inventory, connection owners, approval matrix, test evidence, recovery steps, and change history.

When to Move to Dedicated Software

The SharePoint and Power Automate implementation does not need to be replaced simply because it has been operating for several years. It should be reassessed when business requirements materially exceed the design.

Possible upgrade indicators include:

• Contract volume or workflow concurrency causes recurring processing or reporting constraints
• Multiple subsidiaries require separate legal entities, currencies, policies, and permissions
• Unique folder or item permissions become difficult to administer
• Formal clause libraries and automated redlining become essential
• Regulatory requirements demand specialized records controls or validated systems
• Supplier self-service portals are required
• Complex obligation, milestone, rebate, or service-credit tracking is needed
• Contract data must synchronize deeply with procurement, ERP, finance, CRM, or risk platforms
• Exception rates and manual maintenance continue to increase
• Mobile or offline contract workflows become necessary
• Advanced legal analytics and semantic contract search become core requirements
• Formal vendor support and service commitments are required for the contract platform itself
• Security risk increases because too many users or integrations require broad access

At that stage, the company can evaluate contract lifecycle management, procurement, vendor management, or legal operations platforms. The structured SharePoint records, identifiers, document metadata, and approval history provide a cleaner migration source than the original workbook and email process.

Implementation Checklist

• Confirm renewal, notice, approval, signature, and retention requirements.
• Document current monthly volume and exception types.
• Select Forms, SharePoint, Power Automate, DocuSign, and notification tools.
• Confirm subscriptions, connector entitlement, and DocuSign envelope requirements.
• Create test and production accounts, sites, groups, and connection owners.
• Define least-privilege permissions and sensitive-data restrictions.
• Create Contracts, Renewal Matters, Review Tasks, Approval Log, and Exceptions lists.
• Enable unique keys, indexes, version history, and document metadata.
• Build the Contract Intake and Review Response forms.
• Create the contract document library and standard folder structure.
• Configure field mappings between Forms, SharePoint, approvals, Outlook, and DocuSign.
• Build intake validation and duplicate-event prevention.
• Build contract and matter ID generation.
• Build notice deadline and renewal start calculations.
• Build the daily renewal scheduler.
• Build review task assignment and response processing.
• Build approval thresholds, sequential approvals, and parallel approvals.
• Configure reminders, escalation, delegation, rejection, and return-for-information paths.
• Configure DocuSign dispatch, envelope ID storage, completion handling, and reconciliation.
• Build operational views for intake, overdue work, decisions, negotiations, signatures, and exceptions.
• Implement Try, Catch, Finalize, retry, idempotency, and manual recovery controls.
• Test permissions, duplicates, failures, approvals, signatures, reporting, and audit evidence.
• Pilot with sample data and a controlled group before production rollout.
• Document one-time cost, recurring cost, maintenance, and savings assumptions.
• Add optional AI extraction only after the core workflow is reliable.
• Require human verification of every AI-extracted contract term.
• Assign primary and backup maintenance owners.
• Schedule permission, credential, template, integration, cost, and exception reviews.
• Define the transaction, security, compliance, integration, and maintenance conditions that would justify dedicated software.