What Is KTLO And How To Implement It In Projects

What is KTLO in Software Development?

KTLO or Keep The Lights On encompasses all processes that ensure 24/7 stability and reliability of software systems and regular maintenance of their infrastructure. While KTLO doesn’t add new features, it’s an essential part of IT teams’ responsibilities. However, this work can be time-consuming, potentially slowing down innovation and leading to developer burnout from routine tasks.

What’s Included in KTLO?

Keep The Lights On activities are quite diverse. On one side, these maintenance measures cover reactive tasks – incident response. On the other, there are proactive tasks focused on preventing problems and reducing developer workload. Typically, KTLO in project management includes:

Infrastructure Support: The basic level – servers, network, OS, databases. These need to be monitored, updated, and secured.
Backup Creation: Projects must have tools for data backup and IT resource deployment for system scaling.
System Monitoring: Performance issues, anomalies, and failures need to be tracked, with alerts set up and real-time incident response.
Bug Fixing: All software has bugs. They need to be identified and fixed to minimize downtime.
Standard Updates: These improvements include security patch installation and adaptation to partner API changes to maintain stable operation.
Compliance Assurance: Every organization must update its product to meet security standards, corporate policies, and regulatory requirements.

Understanding what is KTLO requires remembering the importance of balance between reactivity and proactivity. No system is incident-free. But you can’t just react to problems – prevention costs less than dealing with consequences, not to mention customer satisfaction and team morale during crisis situations.

Why KTLO Isn’t Just Another Part of the Lifecycle

While KTLO might seem like daily operational tasks, it specifically requires software developer involvement. This isn’t just about small businesses, projects, or startups lacking specialized roles. Modern systems, especially microservices-based ones, are growing increasingly complex. Their incident risk is rising, while requirements for uninterrupted service become stricter. All this demands deep product knowledge.

In discussing KTLO in software development, developers highlight these advantages:

Better System Understanding: Unlike operations staff, developers know the product architecture’s nuances and limitations, have deeper business logic understanding, and grasp hundreds of code dependencies. Some tasks are impossible without such knowledge.
More Effective Bug Fixing: Due to system complexity, some errors are difficult or time-consuming to address at the support level. Structural code changes might be needed to prevent incident recurrence and ensure stability.
Technical Debt Resolution: Technical debt is inherent in iterative software development but often gets neglected. Proactive KTLO allows integrating time for addressing problematic code or database structure changes.
DevOps Integration: This methodology blurs the lines between development and support. With KTLO, collaboration reaches a level that better maintains product stability, as developers participate in creating CI/CD pipelines, optimizing monitoring, and automation.
New Feature Development: KTLO in project management adds structural changes to the development process, helping implement core innovations in software faster. For example, development infrastructure might improve long-term, and regular refactoring can be conducted.

Key advice: the entire team must understand what Keep The Lights On is. Only then can an organization effectively distribute roles, responsibilities, and resources. For instance, technical support handles initial incident processing and user interaction. Operations teams focus on maintenance and support measures, infrastructure availability, and solving typical problems. Developers handle tasks requiring core code changes, implementing innovations and automation, and addressing technical debt. Project managers oversee and keep everything on track (by the way, the NIX team has some exciting PM vacancies for them).

The Role of KTLO in Project Management

Some might ask: okay, maintenance tasks are necessary, and developers handle them. But is separating KTLO really needed? The answer is yes, it’s essential. KTLO plays a crucial role in project management because it allows:

Understanding Team Workload: Breaking out KTLO in tasks and reports helps visualize how much time routine tasks consume. For instance, IT leaders like Google consider it a red flag when stability maintenance takes over 50% of developers’ time, indicating a need for organizational restructuring.
Resource Planning: If KTLO tasks consume most of developers’ efforts, it might justify creating a dedicated team. This is particularly relevant for high-load systems experiencing active growth, such as startups that have reached a stable operational level.
Setting Priorities: The KTLO concept helps companies better understand the value of each action. Some system maintenance tasks are critical and can’t be postponed, while others can wait behind more important new features.
Process Improvement: Without understanding KTLO, these tasks often become an invisible problem. When you see this workload clearly, you start thinking more about automation tools, debt reduction, architecture review, and overall continuous improvement in teams.
Distributing Responsibilities: KTLO work in organizations can become “nobody’s job.” Developers pass it to operations, who pass it to tech support, and vice versa. But maintaining system stability requires clear responsibility assignment and, when necessary, adding roles from DevOps and SRE engineers to KTLO teams.
Managing Business Expectations: Managers and clients might not understand why iterative feature development takes so long. With KTLO, you’ll have concrete data showing where efforts go, proving why resources should be spent on refactoring and architecture optimization.

When You Need a Dedicated KTLO Team

Sometimes it’s better not to distract developers from core tasks and instead trust Keep The Lights On activities to dedicated teams. However, this decision must be carefully weighed from organizational and financial perspectives. It’s justified when:

What Is KTLO And How To Implement It In Projects | NIX

Developers are Overloaded: Specialists focused on keeping the lights on will free up resources for product development and innovation. Long-term, the organization will offset the costs of a separate team.
System Stability is Critical: In some domains, reliability directly impacts business profitability, such as eCommerce and finance. A dedicated team can minimize problem resolution time and downtime.
Strict SLA Requirements Exist: Service Level Agreements are critical for certain business directions. For instance, if a product needs 99.9% uptime. A team dedicated to KTLO tasks can better manage these risks.
The System is Growing: When millions of users utilize the software, its maintenance becomes more complex, and infrastructure faces more incidents. In such cases, KTLO tasks are sufficient to justify a dedicated team.

Even with all these factors present, it’s important to financially justify the benefits of a team dedicated to maintaining stable operations. ROI (Return on Investment) can help demonstrate its value. The ROI calculation is a topic in its own right, one that receives significant attention in project management books. For now, let’s stick to the basics. For example, you’ll need to calculate how much development team resources spent on KTLO activities cost over a specific period. Then, determine business losses from downtime during the same period, and project the size and budget of a KTLO team. Usually, these specialists cost less than top developers. Ideally, add calculations for potential benefits – after all, innovations will appear faster.

Avoiding Problems with a Dedicated Team

If project managers approach KTLO formally, such systems face problems. On one hand, these specialists, like operations or technical support, might not gain deep product knowledge. On the other hand, they risk burnout and losing focus. To make such teams valuable, software development must be properly structured:

Organize Collaboration: KTLO specialists should be involved in activities like code reviews. This helps them better understand how new features impact the product. Communication tools for quick consultations are also necessary. In complex cases, developers should help with code changes.
Implement Team Rotation: This is a good rule for maintaining stable operation even without a dedicated team. Regular rotation between developers and KTLO specialists improves knowledge sharing and reduces fatigue from repetitive tasks.
Maintain Quality Documentation: Knowledge transfer is important for all projects. But for KTLO teams, architecture description, principles of working with the codebase and infrastructure, and addressing typical problems become especially crucial. For newcomers, this information is invaluable.

How to Build KTLO Processes in Your Project

Situation Analysis: Understand the scope of KTLO activities and their impact on teams. Evaluate the number of tasks like bug fixes, updates, and monitoring over a specific period. This will help identify pain points – where the IT team spends most of their efforts.
Structuring: Divide tasks into reactive (incident response), proactive (refactoring, optimization, and automation that help avoid potential problems), and regular infrastructure maintenance. This approach to KTLO in project management simplifies planning.
Planning: Calculate resources. When keeping the lights on encompasses many tasks, a dedicated team is needed. If maintaining stability takes up to 20-30% of time, the company can organize developer rotation. KPIs are also necessary, such as improving uptime or reducing incidents.
Process Setup: Basic scenarios with incident processing algorithms and roles are needed. For example, who monitors what data and how to respond to application failures. Also specify how such tasks are marked in trackers. This makes KTLO more predictable.
Automation: Less manual work means faster response and better team well-being. Monitoring, backup, and standard updates are easiest to automate. Consider Self-Healing Systems tools for automatic resolution of known failures.
Technical Debt Reduction: Without this, maintaining stable operation is difficult. It will simplify the system and reduce incident risk. Create a backlog of tasks and set priorities in areas with failures. Regular refactoring organization also helps.
Knowledge Transfer: Even with a dedicated team, KTLO work shouldn’t depend on just a few people. Train as many developers as possible (especially newcomers). For example, conduct training on monitoring and incident response. Also create and maintain documentation.
Monitoring: Don’t treat KTLO in project management as static. True IT leaders seek ways for continuous system improvement. This is aided by analyzing KTLO effectiveness, creating dashboards for product status assessment, and team retrospectives.

This represents the basic framework for implementing KTLO in software development projects. However, you can adapt and expand upon it. For instance, you might want to distribute resources by time percentage. A common breakdown might look like this: 40% for system maintenance and support activities, 30% for bug fixes, 20% for technical debt resolution, and 10% for optimization.

However, these proportions depend heavily on your project’s specific needs. For instance, mature products with infrequent innovations typically focus more on daily operational tasks. In contrast, younger organizations often need to emphasize bug fixing and technical debt resolution. That’s why it’s crucial to analyze your specific business context, including its value proposition, needs, and typical system performance challenges. To learn more about the nuances and benefits of this work, you can check out our free PM course.

Key Takeaways for Successful KTLO Implementation

KTLO activities are an integral part of software lifecycle management, essential for maintaining stable operations. It ensures balance between innovation and availability. In this case, routine tasks don’t hinder development. Careful organization, automation, and a proactive approach reduce the number of problems and their business impact. Focusing on these core conclusions will help your team reliably control IT resources and configure Keep The Lights On effectively. And that’s the secret to ensuring uninterrupted operation – whether it’s software or physical products.