This article is based on material originally sourced from IBM and SCMGalaxy. The Three Ways framework referenced below originates from Gene Kim’s DevOps Cookbook (also known as The Phoenix Project companion material).
What Is DevOps?
“DevOps” describes a professional movement and cultural philosophy that advocates a collaborative working relationship between software Development and IT Operations. The goal is to achieve a high rate of planned deployments while simultaneously improving the reliability, stability, resilience, and security of production systems.
DevOps is closely related to—but distinct from—Agile. Agile development focuses on delivering working software in smaller, more frequent increments rather than large, infrequent “big bang” releases. DevOps extends this idea by completing the continuous integration and delivery pipeline: it ensures that code is not only built and tested continuously, but is also reliably promoted to production and delivers value to the end user.
DevOps is sometimes mischaracterized as a rejection of ITIL (IT Infrastructure Library) or ITSM (IT Service Management). In practice, ITIL and ITSM remain useful codifications of the business processes that underpin IT Operations. Disciplines such as service design, incident management, and problem management are entirely compatible with—and often necessary for—a mature DevOps workflow. The goal of DevOps is not simply to increase deployment velocity; it is to deploy features quickly without causing chaos, and to detect and correct incidents rapidly when they do occur.
The Three Basic DevOps Principles (The Three Ways)
The “Three Ways” framework, drawn from DevOps literature, provides a concise model for understanding how high-performing engineering organizations operate.
The First Way: Systems Thinking
The First Way emphasizes optimizing the performance of the entire system, not individual silos. A local improvement that creates a bottleneck elsewhere—or that optimizes one team’s throughput at the expense of another’s—is not a real improvement. This principle applies across the full value stream: from business requirements, through Development, through IT Operations, and out to the customer.
The Second Way: Amplify Feedback Loops
The Second Way is about creating fast, right-to-left feedback loops. Shortening the cycle between an action and its observable consequences allows teams to detect problems early, understand their root causes, and correct them before they compound. This is the foundation of practices such as automated testing, continuous integration, production monitoring, and blameless post-mortems.
The Third Way: Culture of Continual Experimentation and Learning
The Third Way focuses on cultivating a culture that values two complementary things: continual experimentation (which requires accepting risk and learning from both success and failure) and the understanding that repetition and deliberate practice are prerequisites to mastery. This is why practices such as game days, chaos engineering, and internal learning programs are central to mature DevOps organizations.
5 Underrated DevOps Tools Worth Using Every Day
The DevOps ecosystem tends to spotlight newer, cloud-native platforms—Kubernetes, Terraform, Argo CD—while overlooking a set of older, battle-tested utilities that quietly do essential work. Constant improvement is a DevOps value, but improvement does not always mean replacement. The five tools below are lightweight, require minimal configuration, and provide genuine insight into or control over your infrastructure.
1. RANCID (Really Awesome New Cisco confIg Differ)
RANCID is a suite of utilities that automates the collection and revision-control of network device configurations. It connects to routers, switches, and other network equipment, retrieves their running configurations, and commits any changes to a version control repository. This gives operators a full audit trail of configuration changes and makes rollback straightforward. For teams that have not yet migrated to full network-as-code tooling, RANCID is a pragmatic starting point for configuration management.
2. Cacti
Cacti is a round-robin database (RRD)-based statistics graphing tool primarily aimed at network equipment. It polls devices via SNMP (Simple Network Management Protocol) to collect metrics such as interface utilization, CPU load, and memory usage, then renders those metrics as time-series graphs. While modern observability stacks offer richer capabilities, Cacti remains a reliable, low-overhead option for baseline network visibility—particularly in environments where heavier platforms are impractical.
3. lldpd (Link Layer Discovery Protocol Daemon)
LLDP (Link Layer Discovery Protocol) is one of the most underutilized networking protocols in general-purpose Linux environments. Running lldpd on a server causes it to advertise itself to—and receive advertisements from—directly connected network neighbors. The practical result: you can instantly determine which physical switch port a server is connected to, which peer devices are adjacent, and what their capabilities are. This information is invaluable when troubleshooting physical connectivity, validating cabling, or documenting topology.
4. iPerf
iPerf is a network performance measurement tool designed to measure achievable bandwidth between two endpoints. It operates as a client/server pair: one host runs iPerf in server mode and listens for connections; the other runs in client mode and sends traffic. The result is an accurate measurement of throughput, latency, and packet loss across the path between the two hosts. iPerf is essential for validating network capacity after infrastructure changes, diagnosing bottlenecks, and establishing performance baselines before deploying latency-sensitive applications.
5. MUSSH (Multi-host SSH Wrapper)
MUSSH is a shell script wrapper around SSH that allows a single command to be executed across multiple hosts—either sequentially or in parallel. Before configuration management tools like Ansible, Chef, or Puppet became ubiquitous, MUSSH was a common way to push ad-hoc changes or run diagnostic commands fleet-wide. Even today it remains useful for quick, targeted operations where invoking a full orchestration tool would be overkill. Its simplicity is its strength: no agent installation, no inventory database, just SSH.
Why These Tools Still Matter
What RANCID, Cacti, lldpd, iPerf, and MUSSH share is a focus on access and visibility. Each tool gives engineers a clearer, more direct view of what is happening in their infrastructure—which machines are reachable, how the network is performing, what changed in a device’s configuration, and where a cable is physically plugged in. That kind of low-level situational awareness is a prerequisite for fast incident response and reliable operations, regardless of which higher-level platforms sit above it.
In a mature DevOps organization, newer tooling and older utilities coexist. The right question is not “is this tool modern?” but “does this tool solve the problem reliably?” For the use cases above, the answer is still yes.