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

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.