KSUP – Internal Corporate Project Management System

Challenge

KSUP is an internal project management platform built on SharePoint for a large government client. By the time the team joined, the system had grown significantly without consistent engineering standards: tightly coupled frontend/backend code, no reusable component patterns, and a slow build and deploy cycle. New features were expensive to ship and even more expensive to maintain.

The ask was broad: deliver several important new modules — search, financial planning, dynamic field permissions, operational plan updates, and external data sync — while simultaneously improving the codebase health that was slowing everyone down.

Discovery

Each module surfaced a different class of problem:

• Users switched between five separate lists to find entities — no cross-entity search existed.
• CFOs had to manually compile financial plans from operational plans, presales, contracts, and sales — all in separate lists.
• Form fields were visible to everyone regardless of role — no field-level permission system.
• Operational plan updates ran fully automatically, giving users no chance to review or select candidates before committing changes.
• Payment data from the external AX system had to be reflected in sales and contracts, but there was no sync mechanism.

Options Considered

1. Tackle each module in isolation with no shared patterns — rejected. Would repeat the same coupling problems and miss the opportunity to lift the whole codebase.
2. Full refactor before new features — rejected. Not feasible under business deadlines; would deliver nothing for months.
3. Incremental improvement — introduce standards module by module — chosen. Each new module follows clean frontend/backend separation; existing code gets improved opportunistically as it's touched.

Decision

Standardised on React/TypeScript/Redux with redux-saga for side effects and reselect for derived state. Each module gets its own Redux slice, typed API contracts co-designed with the backend developer, and unit test coverage. Shared configuration (e.g. filter schemas) is stored in SharePoint document libraries so behaviour can be changed without a rebuild.

Implementation

Unified Knowledge Base Search

Built a single search page covering all system entities. Adaptive filter sidebar rebuilds depending on the selected content type; each filter type (list, term store, enum field, date range, number range) is described by a JSON config stored in SharePoint — reconfigurable without a code deployment. Filter option loading is lazy and paginated via redux-saga watchers. Contributed improvements back to the open-source react-widgets library — several PRs merged into the official repository.

Financial Plans Module

Introduced a CFO-specific workflow that automatically generates annual financial plans by aggregating data from operational plans, presales, contracts, and sales. A custom jQuery plugin (DataTables + Mustache) renders the JSON report field as an interactive financial table directly on the SharePoint list item page. The C# backend service handles plan generation, director-level validation, and SharePoint event receivers — fully covered by NUnit integration tests.

Field Visibility by Permissions

Developed a UserControl with a PeoplePicker that lets administrators assign field visibility rules to individual users or security groups — no code change required. The JSON configuration is saved via a WCF service; the C# layer resolves group membership recursively at render time. Module ships with full test coverage.

Interactive Operational Plan Updates

The existing OP update process compared old and new sales/contracts automatically and committed changes without user review. Redesigned it to surface a modal with two comparison tables — new positions and changed positions — letting users cherry-pick what to include. The key technical challenge: the existing logic was tightly coupled to SPListItem. Instead of rewriting it, introduced a VirtualSpListItem wrapper in C# — identical API, but operates purely in memory without creating SharePoint list items, allowing candidate selection before any data is committed.

AX Payment Data Integration

Built a SharePoint TimerJob that syncs payment data from the external AX financial system into sales and contract entities. Supports both full and incremental sync modes. Each run validates required fields, matches entities by project code, and serializes payment schedules to JSON for storage. Comprehensive logging with checkpoints ensures every sync can be audited. Covered by integration tests against real AX data.

Outcome

Five production modules shipped on a platform where previously every feature required bespoke integration work. Introducing clean frontend/backend separation and shared Redux patterns reduced time-to-ship for new features by roughly 30%. The filter configuration approach eliminated entire categories of deployments — product managers can now reconfigure search behaviour without involving engineering.