Case Study: Stabilizing a 600-User Redmine with 50+ Plugins and Custom Workflows

International Games System (IGS) is a large-scale gaming company operating across multiple teams and departments, with complex internal workflows and high system usage. Redmine became a central system used daily by hundreds of users.

• 600+ active users

• Multiple teams with different access privileges

• 50+ plugins shaping workflows and processes

• Hosted on Google Private Cloud

The Challenge: Complexity Without Control

As the system grew, so did the complexity. What started as a flexible setup gradually turned into something harder to control.

• Too many plugins affecting the same areas

• Workflows and responsibilities becoming a challenge

• High number of users working simultaneously

• Performance issues appearing under real load

The system didn’t break—but it became unpredictable. And unpredictability at this scale is the real problem.

Proof of Concept (POC)

Before going live, we validated the setup under real conditions to understand how the system behaves at scale.

This phase helped uncover performance limits, plugin interactions, and workflow edge cases early—before they became critical in production. Validation of 50+ plugin compatibility and interactions.

Enabling Cross-Team Collaboration (Custom IssueSync)

One of the key blockers was collaboration between teams.
Two teams needed to work on the same issues—but by design, they should not see each other’s projects.

Instead of breaking permissions or duplicating issues, we introduced a controlled mechanism:

• A custom “SYNC” status marks issues that should be shared

• The other team sees these issues through a filtered view as “Synced”

• Access is limited only to what is explicitly shared

This kept the system clean:

• No duplicate issues

• No permission chaos

• Clear ownership with controlled visibility

Post-Deployment Reality: Where Complexity Hits

Once the system went live with real usage, the true complexity surfaced.

• High concurrency exposed performance limits

• Long-running requests started stacking and slowing the system

• Third-party plugin (Issue Autoflow) couldn’t be debugged when misfiring due to encoded source code

At peak times, response times degraded significantly, and the system required immediate stabilization. That's where RedmineX intervened and stabilized the system very fast.

Stabilization Under Real Load

This is where most projects fail. This one didn’t.
We focused on making the system predictable again:

• Fine-tuned server behavior to match real workload

• Adjusted processing limits so the system stays responsive under load

• Eliminated bottlenecks caused by long-running operations

• Resolved Issue Autoflow conflicts appearing under real usage

At the same time, we worked in high-priority mode:

• Dedicated communication channel for rapid issue reporting

• Continuous iteration based on real usage

• Handling issues across time zones (IGS +6 hours) without unnecessary delays

Infrastructure & Monitoring

To keep the system under control long-term, we ensured full visibility into its behavior.

• Real-time monitoring of performance and load

• Alerting on unusual activity before it escalates

• Clear visibility into database, server, and application health

• Continuous maintenance and updates

Outcome: From Unpredictable to Reliable

IGS now operates a stable and scalable Redmine environment despite its complexity.

• Smooth performance under high user load

• Clear and controlled cross-team collaboration

• Stable behavior across 50+ plugins

• Full visibility into system health

Beyond features: taking ownership of a large-scale Redmine environment

While custom functionality such as IssueSync solved important business requirements, the larger challenge was ensuring long-term stability and maintainability of a complex enterprise environment.

Following the initial deployment, our role extended far beyond feature delivery and included:

• Performance tuning of Puma workers, database pools, threads and application services to match real-world usage patterns.

• Stabilization of an environment containing more than 50 third-party plugins, where compatibility and ownership were critical to avoiding conflicts and unpredictable behavior.

• Continuous monitoring and optimization based on production workload and user growth.

• Planning and execution of future upgrade paths, including compatibility verification across Redmine versions and plugin ecosystems.

• Incident response and enterprise support processes designed to minimize disruption to business operations.

• Long-term ownership of the platform, ensuring that infrastructure, Redmine core, plugins and custom developments continue to work together as a single supported solution.

For organizations operating business-critical Redmine environments, long-term operational stability is often more important than any individual feature. Our objective was not only to implement functionality, but to provide a platform that remains reliable, maintainable and scalable over time.

Key Takeaway

Redmine doesn’t fail because of features. It fails when complexity grows faster than control.

IGS succeeded by turning a complex, overloaded system into a controlled, predictable environment that scales with the business.