ClearPoint Strategy was created by strategy and performance managers who spent years doing reporting work themselves. They built a SaaS platform where organizations manage their goals, KPIs, and initiatives, see progress on live dashboards, and generate reports without manual effort.

ClearPoint is used by Fortune 500 companies, government agencies, banks, hospitals, and educational institutions across the US. The platform integrates with Power BI, Snowflake, and other systems.

ClearPoint hired us to build a new module for their platform. The module lets users create community and public-facing dashboards by pulling data already stored in the system and assembling it into a visual report ready for printing. The designs were finished by our partner design studio, we were responsible for the technical implementation:

• Build a dashboard that pulls content from existing HTML Exports on the platform. Users pick which scorecards, measures, and charts to include and see the result on screen.

• Implement drag-and-drop for dashboard blocks with automatic repositioning of surrounding elements.

• Customize the look of each block individually (colors, fonts, backgrounds, logos, icons).

• Live data updates without page reloads.

• General settings (dashboard name, logo, public or private visibility).

• Scheduling for users to set when to update or publish their dashboards.

• Responsive preview for desktop and mobile.

• PDF preview for printing, saving, or publishing.

The module had to be built as a standalone solution and integrated into an existing platform.

1. EXPERIENCE WITH LARGE-SCALE SAAS PRODUCTS

ClearPoint's codebase had been growing for years. They needed a developer who can navigate a big project with complex data structures and ship a working module inside it. Our team had worked with products of similar scale before, so getting into the codebase didn't require a lengthy ramp-up.

2. OWNERSHIP OVER THE MODULE

The client had no resources to manage external development. They needed someone who would make architectural decisions, pick libraries, and structure the code on their own.

3. STRUCTURED APPROACH

We broke the scope into phases and showed the client what gets delivered, in what order, and when.

Our collaboration with ClearPoint lasted ten months and went through two phases. We started by building a standalone visual reporting module as an outside contractor with one senior developer. After we delivered it, the client brought us into their internal team, gave us access to the core platform codebase, and we expanded the team.

PHASE 1. STANDALONE MODULE

1. Drag and drop that doesn't break the layout

Dashboard blocks needed to be draggable and resizable. When one block moves, the rest automatically recalculate their positions. Styles, colors, and settings on each block are preserved. We used React Grid Layout and customized its resize and repositioning logic to fit the project.

2. Making data reactive

The client's platform saved data only after an explicit save action from the user. Our module had to reflect changes immediately. We chose Zustand for state management and React Query for server-side data handling and caching instead of the project's existing Redux setup. Both worked faster and required less boilerplate.

3. Visual customization

Users configure colors, fonts, backgrounds, logos, and block sizes. Each block individually with ready-made palettes and a manual mode. Every combination had to be rendered correctly.

What changed after module delivery

While working on the module, we got to know the platform architecture and understood how the product was built. Along the way, we suggested things that were outside the scope of our tasks. We picked up work that other developers on the client's team were reluctant to touch.

After we delivered the module, the client decided to continue the partnership. They had accumulated technical debt that was slowing the team down. They handed us the keys to the core codebase, added us to Jira and daily standups. We worked by the same processes as their internal engineers, took part in technical discussions and had input into how the product evolved.

PHASE 2. CORE PLATFORM

Once integrated into the team, we started working on the product core. The codebase had been growing for years and carried accumulated technical debt. We didn't always know how different parts of the system were connected, so every task meant digging under the hood before writing code. Fixing one bug could break ten other things, so each change required understanding what was around it.

1. New instances and entity management

We built new instances that aggregated various project entities and allowed users to monitor and manage them on a single page. We also created and customized individual blocks for overseeing and managing those entities.

2. State management refactoring

The project had two separate stores. We refactored the existing store and merged both into one using Zustand. This improved performance and eliminated duplicated logic.

3. Too many network requests slowing things down

We replaced the default data fetching approach with React Query. This reduced the number of network requests, cut down rendering overhead, and introduced proper data caching.

4. Testing and documentation

We wrote unit tests for individual components and integration tests to verify end-to-end workflows. We documented the codebase, APIs, and usage guidelines to make onboarding easier for future developers and ensure long-term maintainability.

Frontend: React.js, Next.js, TypeScript, React Grid Layout, Material UI

State Management: Zustand, React Query

What ClearPoint got at the end of our collaboration:

• Visual reporting module shipped to production. ClearPoint's clients got a reporting tool that works inside the platform and doesn't require external software to build reports.

• Technical debt under control. When we joined, accumulated debt was slowing development down. We refactored stores, optimized data handling, and left the codebase in a state the ClearPoint team can build on without constant regressions.

• Codebase documented and covered with tests. Unit and integration tests for critical components, documented architecture, APIs, and usage guidelines. The project can continue without us.