Calix Platform Performance Modernization

Overview

Calix provides broadband service providers with tools for managing subscribers, services, and operational workflows. The platform handled large volumes of customer and operational data and relied heavily on MeteorJS's reactive architecture.

When I joined the project, the application was experiencing performance challenges caused by large datasets, excessive reactivity, and an aging architecture that had evolved over several years.

My primary responsibility was to improve system performance, stabilize critical user workflows, and define a long-term modernization strategy.

The Challenge

The platform was built using an older version of MeteorJS and relied extensively on reactive data subscriptions.

While this approach worked well initially, the application had grown significantly over time.

Several screens were processing and rendering more than one million records, resulting in:

• Slow page load times
• Excessive database queries
• High memory consumption
• Expensive reactive updates
• Poor user experience on data-heavy screens

At the same time, the platform needed to continue supporting existing users while improvements were being implemented.

The Solution

Rather than attempting a complete rewrite, I focused on identifying the largest performance bottlenecks and addressing them incrementally.

The strategy included:

• Reducing unnecessary reactivity.
• Optimizing database queries.
• Improving caching mechanisms.
• Limiting data transferred to the client.
• Enhancing rendering performance for large datasets.
• Defining a long-term modernization roadmap.

This approach delivered measurable improvements while minimizing risk to ongoing business operations.

Technical Challenges

Large Dataset Handling

Several workflows involved processing and displaying more than one million records.

Loading large datasets directly into the browser created rendering bottlenecks and degraded the user experience.

Pagination, filtering, and virtual scrolling were introduced to ensure users only interacted with the data they needed.

Reactive Architecture Overhead

Meteor's reactive model was triggering unnecessary updates across multiple parts of the application.

Careful analysis was required to reduce reactivity without impacting user functionality.

Database Performance

Many operations were performing inefficient queries against MongoDB.

Adding appropriate indexes and optimizing query patterns significantly reduced response times.

Caching Strategy

Redis caching was expanded and optimized to reduce repetitive processing and database load, improving overall application responsiveness.

Modernization Strategy

Beyond immediate performance improvements, I was tasked with evaluating the platform's long-term technical direction.

After reviewing the existing architecture, I proposed a modernization strategy that included:

• Separating client and server responsibilities.
• Migrating the frontend to Angular.
• Introducing NestJS as the backend framework.
• Breaking large services into smaller domain-focused services.
• Moving away from heavy reactivity toward event-driven workflows.
• Leveraging workers and asynchronous processing for resource-intensive operations.

The objective was to create a more scalable architecture capable of supporting future growth.

Technologies Used

• MeteorJS
• MongoDB
• Redis
• JavaScript
• Angular (Migration Strategy)
• NestJS (Architecture Proposal)

Outcome

The project resulted in significant performance improvements across critical workflows through caching, query optimization, pagination, virtual scrolling, and reduced reactive overhead.

More importantly, the work established a clear modernization roadmap that addressed both the immediate performance challenges and the platform's long-term scalability needs.

The engagement demonstrated how targeted optimization and architectural planning can extend the life of a mature system while preparing it for future growth.

As a Senior Software Engineer, I was responsible for: * Diagnosing performance bottlenecks across the application. * Optimising MongoDB queries and indexes. * Improving Redis-based caching strategies. * Enhancing API performance and reducing unnecessary processing. * Implementing pagination and filtering mechanisms. * Introducing virtual scrolling for large datasets. * Removing outdated dependencies and modernising parts of the codebase. * Defining a future-state architecture and migration strategy.