Navigating Technical Complexity in an Agile Project

In today’s dynamic software landscape, managing complexity is no longer a peripheral concern; it is central to delivering value. Agile project managers in organisations across industries are continually challenged to understand how technical factors such as programming languages, evolving requirements, and development frameworks affect software project execution. The results point to one clear conclusion: effective integration of agile practices and disciplined project management strategies is critical to navigating complexity and delivering high-quality solutions. An important aspect of software complexity that influences the creation and upkeep of software is codebase size.¹

Understanding Software Complexity in Agile Projects

Modern software systems are increasingly characterised by interconnected modules, real-time data exchange, and evolving user expectations. As features grow in scope and dependencies increase, complexity rises, manifesting in technical debt, rework cycles, and deployment delays, with the help of software.   These organisations are looking for a software supplier which can provide a tool that meets their organisational needs. Although there are a number of tools available in the market, the sole reason for selecting criteria over completing a product is the ease of use. ²   

Some contributing factors commonly observed include: 

• Diverse programming languages within a single codebase (e.g., frontend in React, backend in Node.js or Python) 
• Ambiguous or evolving software requirements, particularly in client-driven projects 
• Integration with third-party APIs or legacy systems often requires custom configurations. 
• Scattered documentation and inconsistent testing practices 

Without a structured project management approach, these issues can cascade into larger delivery risks. 

Strategic Project Management Approaches to Software Complexity 

To combat these challenges, project managers are increasingly turning to a combination of Agile project frameworks, primarily Scrum and Dynamic Systems Development Method (DSDM) and engineering best practices. 

1. Scrum: Promoting Iterative Delivery and Stakeholder Feedback 

Scrum enables structured iteration through two-week sprints, sprint reviews, and retrospectives. This facilitates: 

• Regular inspection and adaptation of work 
• Improved transparency through daily stand-ups 
• Faster alignment with shifting requirements 

These practices help teams deliver working software more frequently and correct course early in the development cycle. 

2. Engineering Best Practices: Ensuring Technical Quality 

To maintain high standards in software delivery and minimise technical debt, project managers actively advocate for the adoption of proven engineering best practices that enhance both code quality and team collaboration. These practices are crucial in Agile environments where continuous delivery and responsiveness to change are prioritised. 

Continuous Integration (CI): 

• CI is the practice of merging all developers’ working copies to a shared mainline several times a day. Every integration is automatically verified by automated builds and tests, allowing teams to detect problems early.³ This reduces the risk of integration issues, catches regressions quickly, and ensures that the codebase always remains in a deployable state. As a result, CI fosters a culture of transparency and reliability, enabling faster and more confident software releases. 

Test-Driven Development (TDD): 

• In TDD, developers begin by writing automated test cases that define the desired functionality of the software before writing the actual code. The cycle typically follows the pattern: write a test, make it pass by writing the minimal code, then refactor the code while keeping the test green. Nevertheless, Test-Driven Development (TDD) can be time-intensive to implement, and evidence suggests that other methods, such as code reviews, may be more effective in identifying defects. As a result, scholars like McConnell (2004) and Balaban et al. (2021) recommend prioritising automated testing for core or high-risk functionality.^{4 5} This process ensures that code is testable, modular, and meets specifications from the start. TDD significantly reduces bugs, improves code coverage, and builds a safety net for future changes or refactoring efforts. 

Pair Programming: 

• Pair programming involves two developers working together at one workstation. One developer, the “driver,” writes the code while the other, the “observer” or “navigator,” reviews each line of code as it is written. The two roles switch frequently. This practice encourages real-time feedback, fosters knowledge sharing, and improves decision-making around design and architecture. It also reduces the number of bugs and increases collective code ownership, which can enhance team cohesion and long-term maintainability. 

Together, these practices align with Agile methodologies, such as Scrum, which emphasise incremental delivery, quality assurance, and team collaboration throughout the development process.⁶ 

3. DSDM (Dynamic Systems Development Method): A User-Focused Agile Framework.  

DSDM is a structured software delivery approach widely adopted for developing software packages and non-IT solutions across various domains. It responds to common pitfalls observed in information technology projects, including budget overruns, missed deadlines, and inadequate customer involvement. 

Complementing Scrum, DSDM emphasises: 

• Active user involvement in every iteration 
• Frequent delivery of usable software components 
• Collaborative decision-making between stakeholders and developers 

This framework ensures that even complex requirements break down into manageable deliverables that align with user expectations. The DSDM approach provides a structured framework for developing and maintaining software systems by using incremental, iterative prototyping. This ensures project schedules are met within a well-managed project environment, as illustrated in Figure 2. 

Research Outcomes: Project-Level Insights 

When agile frameworks are matched with strong engineering practices, project teams are able to: 

• Deliver increments faster. 
• Reduce rework and late-stage bugs. 
• Increase stakeholder(users) satisfaction with clarity and responsiveness. 

These improvements point to the importance of a dual focus on people and process. Agile values must be complemented by discipline in technical execution. 

Project Management Implications 

Project managers play a crucial role in orchestrating this balance. Key recommendations include: 

• Project managers are adopting hybrid Agile frameworks tailored to project needs rather than a one-size-fits-all method. 
• Project managers should prioritise early and ongoing user engagement, especially in high complexity contexts. 
• Project managers need to enforce engineering discipline, not just agile ceremonies, to uphold code quality and reduce technical debt. 
• Project managers should also monitor complexity metrics, such as defect density, code churn, and sprint predictability, to guide effective decision-making. 

Conclusion: Delivering Innovation Through Structured Agility 

These challenges are not merely theoretical. A real-world example can be seen in the Digital DOM Project, a digital transformation for a DOM board to improve operational efficiency and proactive decision-making from pen and paper to a completely digitised system. Despite adopting an Agile framework, the project encountered multiple delays. A key reason for this was that the software engineers lacked a clear understanding of the full project scope. As a result, they implemented technically complex features that were either unnecessary or ambiguous from the user’s perspective. This not only increased the codebase complexity but also diverted efforts from delivering core functionality that stakeholders actually required. The absence of early and sustained user engagement contributed significantly to this misalignment, resulting in avoidable rework and a bloated software architecture. 

Software complexity is the degree of complexity and difficulty associated with creating, testing, and maintaining software systems. Embracing agile is not just about working faster; it’s about working smarter. The fusion of agile project management techniques with software engineering best practices forms the cornerstone of successful delivery in complex environments. 

References:  

1. Sahni, N., & Kaur, R. (2020). Journal of Software: Evolution and Process. “Software Complexity Metrics and Software Quality: A Systematic Literature Review.” ↩︎
2. Brhel, M., Meth, H., Maedche, A., & Werder, K. (2015). Information and Software Technology. “Exploring Principles of User-Centered Agile Software Development: A Literature Review.” ↩︎
3. Sobiesiak, R., & O’Keefe, T. (2011). IBM Corporation / CASCON Proceedings. “Complexity Analysis: A Quantitative Approach to Usability Engineering.” ↩︎
4. McConnell, S. (2004). Microsoft Press. “Code Complete (2nd ed.).” ↩︎
5. Balaban, G., Grytten, I., Rand, K. D., Scheffer, L., & Sandve, G. K. (2021). PLoS Computational Biology. “Ten Simple Rules for Quick and Dirty Scientific Programming.” ↩︎
6. Schwaber, K., & Sutherland, J. (2020). Scrum Guides. “The Scrum Guide: The Definitive Guide to Scrum — The Rules of the Game.” ↩︎