watch

What it does

watch runs a given command repeatedly (every 2 seconds by default) and redraws the terminal with the latest output each time, turning any one-shot command into a live, full-screen dashboard. It's a lightweight alternative to writing a while true; do ...; sleep N; done loop, and adds conveniences like highlighting what changed between runs and a header showing the command and last-refresh time.

Beginner examples

• watch df -h — refresh disk usage every 2 seconds
• watch -n 5 free -h — refresh memory usage every 5 seconds
• watch uptime — keep an eye on load average, updating continuously
• Press Ctrl+C to stop watching and return to the prompt

watch -n 5 free -h

Advanced examples

• Highlight exactly what changed between refreshes: watch -d df -h
• Watch a piped/composed command (must be quoted): watch 'ps aux | grep nginx'
• Stop automatically the moment output changes, e.g. waiting for a job to finish: watch -g 'ps aux | grep myjob'
• Watch without the header bar, for cleaner output to screenshot or pipe elsewhere: watch -t 'date +%T'
• Beep audibly if the watched command starts failing: watch -b 'curl -sf https://example.com/health'

watch -d -n 1 'ss -tn state established'

Common mistakes

• Forgetting to quote commands containing pipes, redirects, or multiple arguments — watch ps aux | grep nginx runs watch ps aux and pipes that into grep, not what most people intend; the correct form is watch 'ps aux | grep nginx'.
• Using watch for something that needs true real-time updates faster than its interval allows — very short intervals (sub-second) can add noticeable overhead from repeatedly forking the command.
• Watching a command that has side effects (like sending a request or writing a file) and not realizing it's actually running that command over and over, not just re-displaying a static result.
• Not realizing watch clears the screen each cycle — scrollback of previous outputs is lost unless you log the underlying command's output separately.

Tips

• Use -d liberally when watching something that changes slowly — it turns "did anything change?" from an eyeball exercise into an instantly visible highlight.
• -g (exit on change) is great for waiting on a condition, like a process disappearing or a file appearing, without polling manually in a loop.
• Pair watch with -n 1 for near-real-time views of fast-changing state like active network connections (watch -n 1 'ss -tn').
• -t (no title) is handy when you want to capture just the command's raw output, e.g. for a screen recording or simplified display.

Best practices

• Always quote multi-part commands passed to watch to make sure the whole pipeline runs under watch, not just the first command.
• Avoid setting extremely short intervals (sub-second) for expensive commands — the overhead of repeatedly spawning the command can itself affect system load.
• Prefer purpose-built monitoring tools (top, htop, iostat -x 1) over wrapping them in watch, since they already have built-in refresh loops and are more efficient.
• Use watch -g instead of manually polling in a custom loop when you just need to block until a condition changes — it's simpler and less error-prone.

Real-world use cases

• Watching disk space fill up during a large file transfer or log rotation: watch -d df -h.
• Monitoring the number of established connections to a service while debugging a connection leak: watch -n 1 'ss -tn state established | wc -l'.
• Waiting for a background deployment or batch job to finish by watching for its process to disappear: watch -g 'pgrep -f my_batch_job'.

Common interview questions

• Why do you need to quote a piped command when using watch? watch treats its argument as the command to run; without quotes, the shell interprets the pipe immediately and only passes the first command to watch, breaking the intended pipeline.
• How would you make a script wait until a process disappears, without polling manually? watch -g 'pgrep -f process_name' — the -g flag exits watch the moment output changes, which happens once pgrep stops finding the process.
• What's the difference between watch and just writing a while loop with sleep? watch provides the loop, a refresh header, and built-in diff highlighting (-d) for free; a manual while true; do ...; sleep N; done loop requires you to reimplement clearing the screen and formatting yourself.