Home › Topics › The IT Department of One › Automation Priorities

The Solo Admin's Automation Priorities


Most automation advice is written for teams with slack — someone can spend three weeks building the elegant pipeline because someone else is holding the ticket queue. You have no such someone. For a department of one, automation has to clear a much higher bar. It must pay back fast, because the hours to build it come out of evenings or deferred work. It must never become its own maintenance burden, because a fragile script farm is just a second job you assigned yourself. The worst outcome in solo automation is not failing to automate; it is automating the wrong things and ending up busier.


So this guide is deliberately opinionated. First, a small scoring framework that tells you where your hours actually leak — it takes minutes to apply and regularly produces surprises. Then the ranked priority list: seven automations, in the order that fits most solo-run shops, with an honest "how far to go" for each. Then the discipline sections nobody writes about: automation debt, when a checklist beats a script, and the guardrails that keep unattended automation from becoming your most productive source of outages. By the end you will have your own top-ten list, scored, with verdicts.


In this guide

  • The scoring framework: hours back per hour in
  • The ranked list: seven automations in order
  • Automation debt: every script is a system you own
  • Automate or document? The judgment call
  • Guardrails for unattended automation
  • Your personal automation audit
  • Where to go next

The scoring framework: hours back per hour in


The only metric that matters solo is hours returned per hour invested. And "hours returned" is bigger than it looks, because a task's true cost has four parts. Score each candidate task from 1 to 3 on each factor and multiply:


  • Frequency — how often it happens. 1 = monthly or rarer, 2 = weekly, 3 = daily or more. Frequency compounds everything else, which is why it is first.
  • Duration — how long each occurrence takes by hand. 1 = minutes, 2 = up to an hour, 3 = hours.
  • Interruptibility — does it arrive on its schedule and break your focus? 1 = you do it when you choose, 2 = somewhat demanding, 3 = it lands randomly and shatters whatever you were concentrating on. A six-minute interruption costs far more than six minutes; the refocus time is real, and solo you pay it alone.
  • Delegability — does automating it let someone else (or the requester themselves) get the result without you? 1 = no, it is yours either way, 2 = partially, 3 = fully self-service afterward. This factor is the quiet giant: automation that removes you from the loop entirely returns hours and attention.

Walk it on a few familiar tasks and the shape of the problem appears:


TaskFreqDurInterruptDelegScore
Password resets and unlocks313327
New-user account setup232336
Weekend patch runs232224
Checking overnight backups312212
Assembling the monthly report13126

Two refinements before you trust the numbers. First, divide by rough build cost: a score-27 task you can automate in an afternoon beats a score-36 task that needs a month. Second, apply the risk override: a few tasks earn their rank not by returning hours but by removing catastrophe. Backup verification is the canonical case, and you will see it jump the queue below. The score finds your time leaks; judgment still sets the order.


The ranked list: seven automations in order


The order below is the framework applied to the shape of a typical solo-run shop, with the risk override doing its work near the top. Your scores may reorder the middle — that is the framework working, not failing — but the first two are close to universal. And the pattern in every entry is the same: automate the mechanism, keep the judgment. Each item says how far to take it, because "fully automated" is not the goal; "no longer costing me attention" is, and those are different finish lines.


1. Monitoring itself

Automation number one is the one this library keeps arriving at: monitoring, because monitoring is the automation of watching. Before any script, the biggest solo time sink is vigilance — checking whether backups ran, whether disks are filling, whether that switch is still upset. A monitoring system does all of that vigilance unattended, forever, and reports by exception. If you have not built the low-upkeep version yet, start there; the solo monitoring setup is the whole recipe, and everything below assumes it exists. How far to go: all the way. This is the platform the rest of the list reports into.


2. Backup verification

The risk-override champion. Everyone automates backups; almost nobody automates proving they restore. Manual verification is the first thing skipped in a busy week — skipped precisely because nothing visibly breaks when you skip it. Automate a test restore: a scheduled job that restores a known file (or spins up a test VM from the backup, if your tooling can). The job reports the result where your monitoring will notice, with a missing report treated as failure. How far to go: automate the daily-or-weekly canary restore and its reporting. Keep the quarterly full-restore rehearsal manual, because that one is testing you and your notes as much as the backup.


3. User lifecycle basics

Onboarding and offboarding are the frequency-times-risk winner in most small shops. They are multi-step, error-prone when rushed, always urgent on someone else's schedule. Offboarding has a security edge, because the forgotten account of a departed employee is a door left unlocked indefinitely. The path: first write the two checklists (that alone removes the errors). Then script the steps that are pure mechanism — create or disable the account, group memberships, mailbox handling, access revocation. That way, a new hire becomes "run the script, then do the human parts." How far to go: automate the account-and-access steps; keep hardware handout, welcome conversation, and manager sign-offs as checklist items. The checklist wraps the script, not the other way around.


4. Patch orchestration

Patching by hand is how solo admins lose weekends. Automate the routine: scheduled deployment, staged so a small test group of machines gets patches first and the rest follow days later. Use maintenance windows your monitoring knows about. Then keep the judgment: you still decide what gets approved, and you still glance at the morning-after report. Your monitoring supplies that report, since it was already watching those machines reboot. How far to go: fully automatic for the routine monthly stream on workstations; scheduled-but-supervised for servers; never blind-automatic for the fragile legacy box that has opinions about updates. Every environment has one.


5. Report generation

Report generation has a low score but high leverage-per-effort, because the work is usually a few clicks in tools you already run. The monthly evidence pack — uptime summary, incident list, capacity trends, backup success record — assembles itself on a schedule and lands in a folder. It converts "I should really pull that together" (never happens solo) into an archive that accrues by itself. That is exactly the receipts file that later justifies budget, tooling, or help. The uptime evidence file guide shows what belongs in it. How far to go: fully automatic generation; you spend ten minutes reading it, zero assembling it.


6. Certificate and domain renewals

The most preventable outage in IT deserves both belts and suspenders. Automate renewal itself wherever the service supports it. Automated certificate issuance and renewal is mature, boring technology now, which is the highest compliment this guide awards. Put a sentry alert on everything, automated or not, because automation that renews certificates can fail too. It fails silently until the padlock breaks. How far to go: auto-renew where the platform allows; monitoring-based expiry countdowns on every certificate and domain regardless. The sentry costs nothing and catches the automation's own bad days.


7. The request deflectors

Everything above automates your tasks; this one automates other people's interruptions. Self-service password reset removes the single most frequent solo interruption at its source — score it yourself: frequency 3, interruptibility 3, delegability 3. Then look at your ticket history and find the five questions you answer most. Publish the answers where users will actually find them (the wiki page you link in every reply, the pinned message, the login-screen note). How far to go: as far as adoption will carry it. A deflector only deflects if using it is easier than pinging you. So put the self-service link where the pain happens, not three clicks deep. This item ranks last only because it depends on habits outside your control; when it lands, it returns more focus than anything else on the list.


Automation debt: every script is a system you own


Now the honesty section. Every script you write is a tiny system, and you are now its vendor, its support department, and its documentation team. It has dependencies that will shift underneath it, assumptions that will quietly expire, and a failure mode you have not met yet. None of that is a reason not to build it. It is a reason to apply the maintenance test before you build: will this outlive its author's attention? If keeping it working will need an hour of care every month, you have not automated a task. You have hired a very needy employee who works for free and lies on their status reports.


Two habits keep the debt payable. First, have a strong preference for boring technology. That means the scripting language your platform already speaks (PowerShell, in most Windows shops), the scheduler built into the OS, plain files over clever databases. Boring parts are the ones still working in three years, and the ones a future contractor — or a future you, at 2 AM — can read without a tutorial. Second, keep the script register: one plain page listing every automation you own. Six months from now "what is running, and what does it touch?" must not be a research project. One line each:


SCRIPT REGISTER - lives with the IT documentation
name              what it does                          touches           runs        last reviewed
offboard-user     disables acct, revokes access, mail   directory, mail   manual      last quarter
canary-restore    restores test file, emails result     backup, NAS       daily 05:30 last quarter
patch-report      collects patch status to one page     all servers       monthly     last quarter
cert-sentry       expiry countdown to monitoring        web, mail, VPN    daily       last quarter

Review the register at the same quarterly calendar appointment as your threshold review. Anything on it that has stopped earning its maintenance gets retired on purpose, not abandoned in place. An automation nobody remembers is a booby trap with a scheduled trigger.


Automate or document? The judgment call


Not everything that repeats deserves a script. Sometimes a great checklist is the better tool, and knowing which is which is a solo survival skill. The checklist wins when the task is infrequent (the script would rot between runs faster than the doc). It also wins when the task is variable (every run needs small judgment calls a script would fumble). Or the task might be touchy: the steps involve systems where a wrong assumption does real damage. In that case, you want a human reading each step, not a script barreling through. The script wins when the steps are identical every time, the frequency is high, and a mistake is cheap or reversible.


The practical pattern is the one from the user-lifecycle item: document first, then automate the stable middle. Write the checklist; run it by hand a few times. The steps that never varied are your automation candidates, and the checklist remains as the wrapper and the fallback. This also means the checklist is always current — it is the spec — which pays again the day someone else has to run it without you. Writing procedures that survive contact with a stressed stranger is the runbooks discipline, and it shares a border with everything in this guide.


A concrete example of the boundary: the annual server-room shutdown for the building's electrical inspection. It happens once a year, the order of operations matters, and half the steps involve looking at things and deciding. Scripting it would produce a fragile artifact that is wrong by next year; a one-page ordered checklist, reviewed the week before, is perfect. Meanwhile the twenty-machine "graceful shutdown" step inside that checklist — identical every time, tedious, error-prone by hand — is a lovely little script. The checklist runs the day; the script runs step six. That division, repeated everywhere, is the whole judgment call.


Guardrails for unattended automation


A team catches a rogue script because five people notice five oddities. Solo, the guardrails have to do the noticing, so build these into everything that runs unattended:


  • Dry-run first. Every destructive script gets a mode that reports what it would do without doing it (PowerShell's -WhatIf convention is the model). New automations run in dry-run mode on schedule for a week before they act; you read their intentions in the morning digest like a parole officer.
  • Notification on action. Every unattended run reports what it did — and a missing report is treated as failure, the same silence-is-not-success rule your backups taught you. A script that acts silently is unauditable; solo, your monitoring inbox is the audit.
  • Ask the blast-radius question. Before anything touches production unattended, ask: what is the worst this can plausibly do at 2 AM with nobody watching? If the answer includes "delete data," "lock everyone out," or "take down the thing that pages me," the automation needs prompts, delays, or narrower permissions. In that case, run it under an account that can only touch what it must.
  • Never automate what you cannot un-automate. Prefer reversible verbs: disable accounts rather than delete them (delete after a delay, by a later run, once nothing screamed). Quarantine files rather than purge them. Stop services rather than uninstall them. Reversibility converts automation mistakes from incidents into annoyances.
  • Promote in stages. Manual → prompted → scheduled-with-report. An automation earns each promotion by being boring at the previous level. Nothing skips grades, however confident you feel at midnight.

Tip: point every script's success, failure, and did-not-run signals at the monitoring system rather than at a mailbox rule you will stop reading. Your monitoring is already the one place you reliably look every morning; automations that report there inherit that reliability for free. And your scripts become just more checks with histories, instead of a second, shadow monitoring system.


Your personal automation audit


Now make it yours. List your top ten time sinks. A week of honest time-logging will hand you the list if you do not trust your memory. The pacing guide makes that exercise its centerpiece. Score each time sink. Here is the worksheet with one shop's plausible answers; replace them with yours:


Time sinkFDIDgScoreVerdict
Password resets313327Deflect: self-service reset
New-user setup232336Automate account steps now
Offboarding12228Automate anyway: risk override
Backup checking312212Automate: canary restore + report
Patch weekends232224Automate staged deployment
Monthly reporting13126Automate: it assembles itself
"Is the internet slow?" pings313218Deflect: status view + monitoring answers it
Disk cleanups21214Document; automate the top offender only
Cert renewals11212Automate + sentry: risk override
Vendor portal wrangling12112Leave manual; checklist the steps

Read your version of this table and the plan writes itself. The top two or three verdicts are your next quarter, one at a time, each passing the maintenance test and wearing the guardrails before promotion. Resist doing five at once; a solo shop digests automation one stable piece at a time, and each finished piece funds the attention for the next.


One last practicality: where do the build hours come from, when the queue is already full? Treat automation work like the maintenance calendar treats restore tests — a recurring, protected appointment, an hour or two a week, that counts as real work because it is. It helps to tell your manager what the hour is for in exactly these terms: "this is the hour that makes password resets stop costing us time forever." One automation per quarter, finished and boring, compounds into a transformed job within a couple of years. Ten half-finished scripts compound into nothing but register entries with question marks. Slow is fine. Finished is the metric.


Where to go next


The quiet theme in all of this: solo automation is not about becoming a programmer. It is about spending attention on purpose. The monitoring watches, the scripts do the identical parts, and the checklists hold the judgment. The register remembers what you built. Together, these free the hours that make a sustainable pace possible and real vacations plausible. The rest of The IT Department of One builds on exactly these reclaimed hours.


Put this into practice with SysPeep Monitor

Item one on the list is the easiest to start today. SysPeep Monitor automates the watching layer — auto-discovering your devices, checking them over SNMP, WMI and SSH, alerting only when something needs you. Its scheduled reports give your scripts and backup jobs one reliable place to prove they ran. The free trial installs on a single Windows machine in an afternoon.

Download Free TrialLearn About SysPeep