The U.S. Army's modernization mandate is driven by the fact that "software drives the modern battlefield." However, mission-critical systems are trapped in decades of bureaucratic, siloed, and slow-moving, hardware-oriented processes.
government

Background

Army Logo

Across the highest levels of government, the mandate is clear: the U.S. Army must accelerate its digital modernization. Senior leaders—from Secretary Hegseth to the Army’s top software and acquisition officials—are emphasizing that software now drives every major weapon system, business process, and training platform. This urgency has led to sweeping policy actions, including Army Directive 2024-02 and the broader Acquisition Transformation Strategy, both of which call for adopting agile, lean, and DevSecOps practices to deliver capability at the speed of relevance.

These initiatives acknowledge a fundamental challenge: decades-old, hardware-oriented processes cannot support the rapid, iterative software development required on modern battlefields. Current conflicts and emerging threats demonstrate that competitive advantage increasingly depends on the ability to update and deploy software quickly. In response, the Army is reforming core institutional processes—from acquisition and contracting to testing, cybersecurity, and talent development—to enable modern software practices and accelerate digital transformation across the force.

This case study will share how Industrial Logic is helping the U.S. Army Software Engineering Center (SEC) with their modernization effort.

Challenges

The engagement began with an onsite assessment by our team of coaches, which unearthed the following challenges the teams are facing:

Insufficient Collaboration

poor_communication.png

Functionally-siloed project teams with part-time team membership inhibit flow.

Current processes, siloed work and individual permissions introduce handoffs and delays in the flow of work.

Functional silos result in higher levels of Work-In-Progress (WIP) and hinder real-time cross-functional collaboration.

Solo development activities Introduce significant delays. Require top down work assignment. Generate lots of "status" meetings. Reduce quality. Increase WIP. Create merge headaches.

Asynchronous peer reviews lead to idle states in the flow of work.

Waterfall Thinking

psych_checklist_small.png

Waterfall, phase-gated processes prevent the flow of work.

Feedback loops are too long when working in large batches in phases.

Individual work items don’t independently flow through the value stream without a larger construct (project or release).

Waterfall processes and practices result in large batches which delay the delivery of customer value and feedback.

Large batches encourage parallel work (i.e., working on multiple releases at the same time).

Batch size, risk, and cycle time are directly proportional. As batch sizes grow larger, so do the others.

Insufficient Workflow Visualization

evolve_small.png

Tooling is already in place to visualize each team’s workflow but is poorly used.

Work items stay in progress for weeks, months, or even years.

Visualizing the entire value stream from requirements to delivery is missing.

Work items are often tasks assigned to individuals and not units of customer-facing value.

The current usage of the workflow tool doesn’t support managing the flow of work through the value stream.

Burdensome Requirements Process

user_looking_small.png

Traditional requirements practices are problematic due to requirements are often defined entirely upfront, inhibiting iterative development.

A lack of a "Source of Truth" leads to excessive information duplication across multiple documents and subsequent high maintenance overhead and inconsistencies.

The true "Voice of the Customer" is often missing. Stakeholders struggle to find necessary information.

Furthermore, the requirements are difficult to verify, easily fall out of sync with the code over time, and merely sharing documentation does not ensure a shared understanding among the team.

Over Specialization with Manual Processes

manual-processes.png

Relying on individual specialists for handoffs creates single points-of-failure and bottlenecks. Successful cross-functional teams need "T-Shaped" members—deep expertise in one domain plus broad complementary skills.

Current manual CM builds and producing "production ready" binaries outside the main pipeline is inefficient; binaries should be built once and promoted across environments.

Testing relies too heavily on manual processes.

Lack of Quality-First Practices

slow_qa.png

The lack of technical and collaborative practices is hindering CI/CD adoption. Implementing these practices is vital for establishing the technical safety needed to deliver high-quality software in small steps.

While E2E test automation using hardware-in-the-loop has progressed, over-reliance on UI-driven E2E tests to automate all manual procedures is risky. These UI-driven tests are slow, fragile, and poor feedback mechanisms, leading to brittle tests requiring constant maintenance. Furthermore, their inability to localize errors significantly increases bug identification time and difficulty.

Solutions

Industrial Logic’s coaches identified the following remedies to address the team’s biggest challenges:

benefit
Ensemble Programming:

The Industrial Logic coaches guided the team in ensemble programming which fostered collaboration, collective responsibility, improved quality, lower WIP, and decreased cycle time.

mob_dondont
Moving Into A Collaborative Work Mode:

The ensemble worked together to get a story finished with shared responsibility from start to finish. The members would help each other with tasks which may not be strictly theirs from a reporting structure. (i.e. Developers might help the tester’s test. Tester’s might research information needed for the Developers.)

TDD_story
CI/CD Pipeline:

customization
Attention To Technical Excellence:

The Developers learned test-driven development, micro-testing, and refactoring.

They put together a set of instructions to properly configure their IDE to compile and run their system.

remove
Eliminate Waste:

The product backlog was streamlined, old defects resolved, and unnecessary items removed.

Coached the ensembles to working only on small user stories which were on the order of 1-3-days, and tracked them on a Kanban board.

deployment
Characterization Testing:

deployment
Creating an Agile Mindset:

Results and Benefits

WORKFLOW AND PLANNING:

  • Improved Jira workflow and issue types to better visualize WIP and flow
  • Limiting WIP
  • Definition of Ready and Definition of Done to make explicit what it means for work to be ready and to be done
  • Focus on finishing work rather than starting more
  • Tracking waste and waits in the existing process (and areas of improvement) via the waste snake
  • Retrospectives that lead to actionable improvements
  • Backlog items broken down with tasks and acceptance criteria
  • Weekly backlog refinement to get the entire teams’ feedback and engaged in planning work
  • Experimentation through spikes
specifications
“Our team loved what Industrial Logic helped us do. They trained and coached our staff to use a better, more repeatable way of developing quality software, which delivered far better results for our business.” Director, Systems Development, Kappa

defects

COLLABORATION:

  • Removing handoffs and stalled work (requirements, CM, tester feedback, code review feedback) by working in an ensemble.
  • Closer collaboration between developers via ensemble development
  • Closer collaboration between developers and testers via ensemble development
  • Daily huddle instead of separate “sub-team” weekly meetings
  • Daily huddle review of test and dev progress (able to change directions faster)
  • Coaches Corner sessions held weekly to accelerate and reinforce team learning

TOOLING:

  • Pipeline builds triggered off of developer commits
  • Automated refactoring safely via the CLion IDE
  • CLion’s automated code creation and context actions reducing developer cognitive load
  • mob.sh as a way for teams to collaborate in code
  • Collaboration in MS Whiteboard (waste snake, retrospectives, learning board)
specifications

Summary

TBD...