🚀 15 CLI Tools That Make a DevOps Engineer’s Life Easier

🚀 15 CLI Tools That Make a DevOps Engineer’s Life Easier

Less clicking. More coding. Faster workflows. Here are 15 command-line tools that can simplify your daily development, DevOps, and engineering work.

Arvind Verma

Oct 23

You open Postman to test an API. Then Docker Desktop to inspect a container. Then a browser to check a GitHub pull request. Next, you open another terminal to investigate Kubernetes, another window to inspect logs, and a database client to run a query.

Ten minutes later, you have twelve windows open, three terminals running, and somehow you are still trying to find the error that started this whole adventure. 😅

Sound familiar?

As DevOps engineers, we spend a surprising amount of time switching between applications instead of solving the problems in front of us.

But what if some of those repetitive tasks could be handled directly from your terminal?

A good command-line interface, or CLI, can help you test APIs, inspect containers, investigate Kubernetes workloads, review Git changes, query databases, and monitor system resources without constantly switching applications.

The goal isn’t to eliminate every graphical interface. GUIs are useful, especially for complex workflows and collaboration. The goal is to reduce unnecessary friction and make common engineering tasks faster, repeatable, and easier to automate.

In this article, we’ll explore 15 CLI tools, learn what each one does, install them on Windows PowerShell, Windows CMD, or Ubuntu/Linux where supported, and walk through practical examples you can use in your own DevOps workflow.

Our principle is simple: Less clicking. More coding. Better workflows. ⚙️

Part 1 of 3: Replace Repetitive API, Kubernetes, Docker, and Git Work

1. xh: Test APIs without opening Postman

Imagine a developer reports that an API is returning HTTP 401. You need to check the endpoint, inspect the response, and verify whether authentication is involved.

Opening a full API client for every small request can be unnecessary.

xh is a command-line HTTP client that lets you send requests and inspect responses directly from your terminal.

Installation

Windows PowerShell

winget install ducaale.xh

Windows CMD

winget install ducaale.xh

Ubuntu/Linux

Check whether your Ubuntu release provides the package:

sudo apt update
sudo apt install xh

If it is unavailable, follow the official xh installation guide.

How to use it

Send a GET request:

xh GET https://jsonplaceholder.typicode.com/posts/1

Send a POST request containing JSON fields:

xh POST https://jsonplaceholder.typicode.com/posts title="Test post" body="Hello from xh" userId:=1

You can inspect the response directly in the terminal and use the same commands in scripts.

How it helps in production

Suppose your application returns HTTP 500, but you don’t know whether the issue is in the application, API gateway, or upstream service.

You can send a direct request, inspect the response, and compare the behavior with another endpoint.

Why engineers like it: Quick API checks become easier to repeat, automate, and include in troubleshooting scripts.

What it replaces: Some everyday Postman tasks, not the entire graphical API-testing and collaboration experience.

2. k9s: Manage Kubernetes without endless kubectl commands

Kubernetes is powerful. Its command syntax can also become a small endurance test when you’re investigating a production incident.

You might run kubectl get pods, inspect a deployment, describe a pod, check logs, and repeat the process across namespaces.

k9s gives you an interactive terminal interface for exploring Kubernetes resources.

Installation

Windows PowerShell

winget install derailed.k9s

Windows CMD

winget install derailed.k9s

Ubuntu/Linux

One supported option is Snap:

sudo snap install k9s

If Snap is unavailable, use the official k9s installation guide.

You also need a configured Kubernetes context and working cluster access.

Verify your connection:

kubectl get nodes

Start k9s:

k9s

How to use it

Once the interface opens, you can explore resources using its command mode.

Common resource views include:

• :pods to inspect pods.

• :deployments to inspect deployments.

• :services to inspect services.

• :nodes to inspect nodes.

Select a pod and press l to view its logs. Use the interface’s help and keybinding information to explore other operations.

Real-world scenario

Your EKS deployment is returning HTTP 503. Several pods are restarting, and the application team says the code hasn’t changed.

Instead of repeatedly switching between commands, use k9s to inspect pod health, logs, events, and deployment status.

You might discover that the pods are failing readiness probes or that the application cannot connect to its database.

Why it helps: k9s makes cluster exploration faster. It does not replace understanding Kubernetes networking, scheduling, probes, or application failures.

Production reminder: Confirm your active context and namespace before making changes. Accidentally modifying the wrong cluster is a very expensive way to learn keyboard shortcuts.

3. lazydocker: Inspect Docker containers from one interface

Docker troubleshooting often involves several commands:

docker ps
docker images
docker logs <container>
docker inspect <container>

These commands are useful, but jumping between them can slow down routine investigations.

lazydocker provides an interactive terminal interface for viewing containers, images, logs, and related Docker information.

Installation

Windows PowerShell

winget install JesseDuffield.lazydocker

Windows CMD

winget install JesseDuffield.lazydocker

Ubuntu/Linux

Use the official lazydocker installation guide for the recommended method for your distribution.

If Go is already installed, one option is:

go install github.com/jesseduffield/lazydocker@latest

Ensure the Go binary directory is included in your PATH.

How to use it

First, make sure Docker is running:

docker ps

Then launch:

lazydocker

Explore your containers, inspect their logs, and review image information from the interface.

Real-world scenario

A container keeps exiting shortly after startup. Instead of guessing, inspect the container’s status and logs.

You might discover a missing environment variable, an invalid configuration file, or an application startup error.

Why it helps: You get a convenient overview of container activity without memorizing every Docker command.

4. dive: Discover why your Docker image is so large

Your application works correctly, but its Docker image is 1.8 GB.

That means larger image transfers, potentially slower deployments, and more storage consumption. It may also mean you are shipping unnecessary files.

dive helps you examine Docker image layers and understand what contributes to image size.

Installation

Windows PowerShell

winget install wagoodman.dive

Windows CMD

winget install wagoodman.dive

Ubuntu/Linux

Follow the official dive installation instructions for supported packages or release binaries.

How to use it

Build your image:

docker build -t myapp:latest .

Inspect it:

dive myapp:latest

Explore the image layers and look for unnecessary dependencies, caches, generated files, and build artifacts.

Real-world scenario

Your Dockerfile installs compilers and build tools, then copies everything into the final runtime image.

By reviewing the image layers, you may identify opportunities to use multi-stage builds, remove unnecessary files, or improve .dockerignore.

Why it helps: Smaller images can reduce transfer time and storage needs. A cleaner image can also reduce the amount of unnecessary software shipped with your application.

5. lazygit: Review Git changes without memorizing every command

Git is essential for DevOps engineers, but even experienced developers occasionally stage the wrong file or forget what they changed.

lazygit provides an interactive terminal interface for reviewing changes, staging files, committing changes, and managing branches.

Installation

Windows PowerShell

winget install -e --id JesseDuffield.lazygit

Windows CMD

winget install -e --id JesseDuffield.lazygit

Ubuntu/Linux

If Go is installed:

go install github.com/jesseduffield/lazygit@latest

See the official lazygit installation guide for other supported methods.

How to use it

Move into your Git repository:

cd my-project

Launch lazygit:

lazygit

Review modified files, stage only the changes you intend to commit, and inspect the diff before creating the commit.

Press ? inside the interface to see available keybindings.

Real-world scenario

You modify five files while debugging a Terraform deployment. Only two files belong in the final change.

Review the files and stage them individually instead of committing everything blindly.

Why it helps: It makes Git operations easier to inspect and reduces accidental commits.

6. hunk: Make reviewing code changes easier

Reviewing a diff is one of the simplest ways to catch mistakes before they reach production.

A single changed environment variable, security rule, or Terraform resource can have consequences far beyond the size of the code change.

Hunk is a terminal-oriented diff and review tool.

Installation

Windows PowerShell

winget search hunk

Windows CMD

winget search hunk

These commands search available packages; they do not install Hunk. Confirm the package identity and installation instructions before installing anything.

Ubuntu/Linux

Follow the official Hunk documentation for the current installation method and supported platforms.

How to review changes

You can always start with Git’s built-in diff commands:

git diff
git diff --staged

Use Hunk according to its documented command syntax to navigate and review changes.

Real-world scenario

Before merging a Terraform pull request, review the exact changes to networking, IAM permissions, and infrastructure configuration.

A careful review might reveal a security group rule that accidentally exposes a service or a change that could replace an important resource.

Why it helps: Better diff review means fewer surprises during deployment.

Part 2 of 3: GitHub, Notifications, Databases, Files, and System Monitoring

7. GitHub CLI: Bring pull requests and workflows into your terminal

How often do you leave your terminal, open GitHub, find a repository, locate a pull request, and check whether its CI pipeline passed?

GitHub CLI (gh) lets you perform many common GitHub operations directly from your terminal.

Installation

Windows PowerShell

winget install --id GitHub.cli

Windows CMD

winget install --id GitHub.cli

Ubuntu/Linux

Follow the official GitHub CLI Linux installation guide for your Ubuntu release.

How to use it

Authenticate with GitHub:

gh auth login

List pull requests:

gh pr list

Inspect a pull request:

gh pr view 123

Replace 123 with the actual pull request number.

Real-world scenario

Your deployment failed after a recent merge. You can inspect the relevant pull request, review discussions, and investigate workflow runs without constantly switching to a browser.

Why it helps: It connects source-control collaboration and CI/CD investigation to the terminal you already use.

8. ntfy: Get notified when a script finishes

Some jobs take several minutes. Others run in the background while you investigate something else.

Instead of checking repeatedly, you can send a notification when a task completes.

ntfy lets scripts publish notifications to a topic that you can subscribe to.

Installation

Windows PowerShell

If you use Scoop and the package is available in your configured repositories:

scoop install ntfy

Windows CMD

With Scoop already installed:

scoop install ntfy

Ubuntu/Linux

Follow the official ntfy installation documentation for the correct client or server package.

The Homebrew option below requires Homebrew to be installed on Linux:

brew install ntfy

How to use it

Publish a notification:

ntfy publish devops-alerts "Build completed"

Subscribe to a topic:

ntfy subscribe devops-alerts

Real-world scenario

You have a script that validates infrastructure configuration or performs a lengthy build. When it finishes, the notification lets you know that it is ready for review.

Why it helps: You spend less time checking whether background work has finished.

Security note: Do not publish credentials, secrets, or confidential production information to public topics. Configure access controls appropriate to your environment.

9. pgcli: Work with PostgreSQL more comfortably

When investigating an application issue, you often need to query the database directly.

The standard PostgreSQL client works well, but autocomplete and syntax highlighting can make interactive queries easier to write and review.

pgcli provides these conveniences for PostgreSQL.

Installation

Windows PowerShell

py -m pip install --user pgcli

Windows CMD

py -m pip install --user pgcli

These commands require Python and pip. Native Windows installations may encounter dependency or terminal limitations; Ubuntu through WSL is an alternative.

Ubuntu/Linux

For supported Ubuntu package versions:

sudo apt update
sudo apt install pgcli

For other installation options, use the official pgcli guide.

How to use it

Connect to a database:

pgcli -h localhost -U appuser -d appdb

Replace the connection details with your own.

Then run a query:

SELECT id, status
FROM orders
LIMIT 10;

Real-world scenario

An API claims that an order does not exist. Before assuming the application code is broken, query the relevant table and verify whether the record is present.

Why it helps: Faster interactive querying can make database troubleshooting less repetitive.

10. mycli: Make MySQL queries easier to write

If you work with MySQL, mycli offers a similar experience with autocomplete and syntax highlighting.

Installation

Windows PowerShell

py -m pip install --user "mycli[all]"

Windows CMD

py -m pip install --user "mycli[all]"

Python must be installed first. If native Windows dependencies cause problems, use Ubuntu through WSL.

Ubuntu/Linux

One option on supported Ubuntu releases is:

sudo apt update
sudo apt install mycli

See the official mycli installation guide for other methods.

How to use it

Connect to MySQL:

mycli -h localhost -u appuser -p appdb

Enter your password when prompted.

List tables:

SHOW TABLES;

Real-world scenario

A service returns database errors after a deployment. You can connect to the database and verify the schema and expected records before investigating deeper application-level problems.

Why it helps: It makes frequent database investigations more comfortable and efficient.

11. yazi: Navigate project files without endless cd commands

Large repositories often contain application code, Helm charts, Terraform modules, Kubernetes manifests, and deployment scripts.

Navigating this structure with repeated cd, ls, and dir commands works, but it can become tedious.

yazi is a terminal file manager that supports directory navigation and file previews.

Installation

Windows PowerShell

Use a Windows installation method listed in the official yazi documentation. Verify the supported binary or package for your environment.

Windows CMD

Use the same supported Windows installation method. If you install a binary, make sure its directory is available through your PATH.

Ubuntu/Linux

Follow the official yazi installation guide for your distribution and its prerequisites.

How to use it

Open the current directory:

yazi

Browse folders, inspect files, and use the documented keyboard shortcuts to move around your project.

Real-world scenario

You need to find the Helm values file responsible for a deployment configuration. Instead of repeatedly changing directories, use yazi to navigate and preview the repository structure.

Why it helps: It makes file navigation faster while keeping you in the terminal.

12. btop: Monitor system resources in real time

A Linux server is slow. Is CPU usage too high? Is memory running out? Is one process consuming an unusual amount of resources?

btop gives you a live terminal dashboard for inspecting system resources and running processes.

Installation

Windows PowerShell

For Linux server monitoring, install btop inside Ubuntu or WSL. For native Windows use, check the project’s current supported releases and packages.

Windows CMD

Use a verified native Windows package if available for your environment, or run btop inside a Linux environment.

Ubuntu/Linux

sudo apt update
sudo apt install btop

How to use it

Start the dashboard:

btop

Review CPU usage, memory, processes, and other available resource information.

Real-world scenario

A VM’s response time has increased. btop can help you identify a process consuming excessive CPU or a system experiencing memory pressure.

Why it helps: It provides a quick overview before you move to deeper investigation with tools such as top, free, ps, and your monitoring platform.

Part 3 of 3: Log Investigation, AI Coding, and Better Terminal Workflows

13. lnav: Investigate logs without reading thousands of lines manually

Logs are useful until you have to search thousands of lines while an incident is unfolding.

lnav is a terminal log viewer that helps you navigate and investigate log files.

Installation

Windows PowerShell

Check the official lnav downloads for current Windows support. If your environment is not supported, use Ubuntu through WSL or investigate logs on the Linux host.

Windows CMD

Use a supported Windows binary if provided by the project. Otherwise, use the Linux/WSL installation route.

Ubuntu/Linux

sudo apt update
sudo apt install lnav

If the package is unavailable for your Ubuntu release, consult the official download page.

How to use it

Open a system log:

lnav /var/log/syslog

Or open an application log:

lnav /var/log/myapp/application.log

Use the correct file path for your environment.

Real-world scenario

An application begins returning HTTP 500 responses after a deployment. Inspect the logs around the time of the failure and look for exceptions, failed dependencies, or configuration errors.

Why it helps: It makes log investigation easier to navigate and can help you identify relevant evidence more quickly.

14. Claude Code: Use AI assistance from your terminal

AI coding tools are becoming part of everyday engineering workflows. Used carefully, they can help you understand unfamiliar repositories, explain configuration files, draft changes, and investigate errors.

Claude Code brings AI assistance into a terminal-based development workflow.

Installation

Windows PowerShell

The official Windows installer can be launched with:

irm https://claude.ai/install.ps1 | iex

Review remote scripts and their permissions before executing them.

An alternative documented package-manager route is:

winget install Anthropic.ClaudeCode

Windows CMD

Using WinGet:

winget install Anthropic.ClaudeCode

The PowerShell installation script is intended for PowerShell, not CMD.

Ubuntu/Linux

Use the official installer:

curl -fsSL https://claude.ai/install.sh | bash

Check the official Claude Code getting-started documentation for current prerequisites and authentication steps.

How to use it

Verify the installation:

claude --version

Move into your project:

cd my-project
claude

Start with a read-only request:

Explain the repository structure and identify where application configuration is loaded. Do not modify any files.

After reviewing the response, ask for a small, specific change. Inspect the resulting diff and run tests before accepting the work.

Real-world scenario

You inherit a Terraform repository with multiple modules and unfamiliar variables. Claude Code can help explain how modules connect, where variables are passed, and which files deserve closer inspection.

Why it helps: It can shorten the time required to understand unfamiliar code and prepare changes.

Production rule: Review generated code, protect secrets, restrict permissions, and test changes. AI assistance does not transfer engineering responsibility to the machine.

15. Zellij: Organize multiple terminal sessions

During a deployment, you may need to watch application logs, check Kubernetes resources, run tests, and execute Git commands simultaneously.

Opening terminal after terminal can quickly become its own operational incident.

Zellij is a terminal workspace manager that helps organize panes, tabs, and sessions.

Installation

Windows PowerShell

Follow the official Zellij installation documentation for supported Windows options.

The project also documents a PowerShell launcher:

irm https://zellij.dev/launch.ps1 | iex

Review remote scripts before executing them.

Windows CMD

Download a supported Windows binary from the official Zellij releases, extract it, and run zellij.exe. Add the executable’s directory to your PATH if you want to invoke it from any location.

Ubuntu/Linux

If Rust and Cargo are installed:

cargo install --locked zellij

Alternatively, use a package manager supported by your distribution.

How to use it

Start a workspace:

zellij

Create panes and tabs to organize different activities. For example:

• Pane 1: Follow application logs.

• Pane 2: Inspect Kubernetes resources.

• Pane 3: Run tests or deployment validation.

• Pane 4: Review Git changes.

Use Zellij’s help and keyboard shortcuts to manage your workspace.

Real-world scenario

During a production deployment, you need to verify application health while watching logs and checking the status of Kubernetes workloads.

Zellij helps keep the relevant terminal sessions organized in one workspace.

Why it helps: Fewer scattered windows and a more structured terminal workflow.

🛠️ How to build your CLI toolkit without overwhelming yourself

You do not need to install all 15 tools immediately. That would turn a productivity exercise into a package-management marathon.

Start with the problems you encounter most often.

Step 1: Check your environment

On Windows PowerShell, verify WinGet:

winget --version

Check Python if you intend to install Python-based tools:

py --version
py -m pip --version

On Ubuntu/Linux:

sudo apt update
sudo apt install git curl python3 python3-pip

Install additional prerequisites only when a selected tool needs them. For example, k9s requires Kubernetes access, and lazydocker requires a working Docker environment.

Step 2: Verify each installation

After installing a tool, confirm that the executable is available:

gh --version
lazygit --version
btop --version

Other tools may use different version commands. Consult their documentation when necessary.

If Windows reports that a command is not recognized, check whether the executable is installed and available in PATH. Open a fresh terminal before investigating further.

Step 3: Choose the right shell

PowerShell, CMD, and Bash are different environments.

• PowerShell: A strong default for modern Windows administration and scripting.

• CMD: Useful for traditional Windows commands and batch scripts.

• Ubuntu/Linux or WSL: A practical environment for Linux-focused DevOps tools and workflows.

A tool may support one environment better than another. Don’t assume a command that works in Ubuntu will work natively in CMD.

Step 4: Start with three tools

A practical beginner setup might be:

1. lazygit for Git review.

2. xh for API testing.

3. btop for Linux resource monitoring.

If Kubernetes is part of your daily work, add k9s after confirming your cluster access.

Once you are comfortable with the basics, add tools for Docker, logs, databases, and terminal workspaces.

🚨 Common mistakes that make CLI workflows harder

1. Copying commands without understanding them

A command that installs a package is different from one that downloads and executes a remote script. Read what the command does before running it, especially when elevated permissions are involved.

2. Treating all Windows shells as interchangeable

PowerShell commands, CMD commands, and Bash commands have different syntax and capabilities. Choose the command for the shell you are actually using.

3. Ignoring security

Never put production passwords, API tokens, or private data into public notification topics or shell commands that may be saved in history.

4. Installing unverified packages

Verify the official project, package identity, and installation method. Similar package names do not guarantee that two packages are maintained by the same project.

5. Using interactive tools without learning the underlying concepts

k9s won’t teach you Kubernetes networking automatically. lazydocker won’t explain container architecture by magic. Tools accelerate workflows, but fundamentals still matter.

6. Using powerful tools carelessly in production

Before making changes, verify the cluster context, namespace, repository, and target environment. Use read-only commands when investigating an unfamiliar system.

🎯 Key takeaways

The real advantage of CLI tools is not the number of applications you can remove. It is the amount of unnecessary friction you can eliminate.

• xh: Test APIs quickly.

• k9s: Explore Kubernetes resources.

• lazydocker: Inspect containers and logs.

• dive: Analyze Docker image layers.

• lazygit: Review and stage Git changes.

• hunk: Improve diff review.

• gh: Manage GitHub workflows.

• ntfy: Send script notifications.

• pgcli: Query PostgreSQL.

• mycli: Query MySQL.

• yazi: Navigate project files.

• btop: Monitor system resources.

• lnav: Investigate logs.

• Claude Code: Get AI assistance with code.

• Zellij: Organize terminal sessions.

Start small. Learn the commands. Understand the risks. Introduce each tool into a workflow where it provides a measurable benefit.

That is how you build an engineering environment that feels faster without making it harder to maintain.

Conclusion: Less clicking. More coding. Better workflows.

You don’t have to abandon every GUI to become a more effective DevOps engineer.

You need to recognize when a terminal workflow is faster, easier to repeat, or simpler to automate.

Use graphical applications when their features genuinely help. Use CLI tools when they remove repetitive work. Combine them with scripting, version control, and good operational practices.

Because productivity isn’t about typing commands as quickly as possible. It’s about spending less time navigating tools and more time understanding systems, solving problems, and delivering reliable software. 🚀

Hashtags

#DevOps #DevOpsEngineer #PlatformEngineering #CLI #Linux #Ubuntu #PowerShell #WindowsCMD #Kubernetes #Docker #Terraform #Git #GitHub #CloudComputing #SRE #Automation #DeveloperProductivity #SoftwareEngineering #DevSecOps

Follow Me

If you enjoyed this article and would like more practical DevOps, Cloud, Kubernetes, AWS, Terraform, CI/CD, and Software Engineering content, connect with me on LinkedIn.

LinkedIn: https://www.linkedin.com/in/arvindverma021/

Arvind Verma is free today. But if you enjoyed this post, you can tell Arvind Verma that their writing is valuable by pledging a future subscription. You won't be charged unless they enable payments.

Pledge your support

© 2026 Arvind Verma
548 Market Street PMB 72296, San Francisco, CA 94104