You're sitting at your desk, coffee cooling beside you, when the email hits your inbox. It's from HR, and the subject line makes your stomach drop. A colleague—someone you've worked with for years, maybe shared lunch with just last week—has passed away. Among the immediate grief comes a technical task that feels profoundly wrong: you need to disable their accounts, revoke their access, and essentially erase their digital presence from the systems they helped build.
This isn't just another offboarding ticket. It's different. And if you've been in IT long enough, you know exactly what I'm talking about.
That Reddit post from a sysadmin who had to disable a deceased coworker's account resonated with thousands because it touches on something we rarely discuss: the intersection of technical processes and human emotion. In 2026, with automation reaching into every corner of IT operations, we have an opportunity—and a responsibility—to handle these moments better. Not just more efficiently, but more humanely.
The Unspoken Burden of IT Professionals
Let's be honest: nobody goes into system administration thinking they'll become the digital undertaker. We sign up for solving puzzles, building resilient systems, and keeping the lights on. But part of keeping those lights on means managing the entire lifecycle of digital identities, including their endings.
When that Reddit thread blew up with hundreds of comments, a pattern emerged. Sysadmins weren't just sharing similar experiences—they were expressing a collective discomfort with the process. "It feels like you're deleting the person," one commenter wrote. Another mentioned the eerie silence after disabling accounts, followed by the automated "out of office" replies that keep hitting distribution lists for weeks.
What makes this different from standard termination procedures? Several things, actually. There's no handover period. No knowledge transfer. No final conversation about where files are stored or what projects need attention. Just... absence. And you're left with the technical cleanup while everyone else is processing the loss.
In many organizations, there's no documented process for this scenario. You're flying blind, making judgment calls about what to preserve, what to archive, and what to disable immediately. Should you keep their email account active for a while in case important messages come through? What about their code commits or documentation? These aren't just technical questions—they're ethical ones.
Why Current Automation Falls Short
Here's the irony: we've automated nearly everything else. New hire provisioning? Automated. Standard termination workflows? Automated. Password resets, access requests, even some troubleshooting—all automated. But death in the workplace? That still often requires manual intervention, and there's a reason for that.
Most identity management systems are built around binary states: active or inactive. They don't account for the nuanced states between those extremes. When someone leaves voluntarily, we might have a 30-day grace period before full deprovisioning. When someone is terminated, we might cut access immediately. But when someone passes away?
Well, that's where things get messy. You might need to:
- Preserve access to certain systems for their team to retrieve work
- Maintain email forwarding for critical business communications
- Archive their files and communications differently (for both practical and legal reasons)
- Handle notifications to external partners and systems
- Manage the psychological impact on their direct teammates who might still see their account in lists
Standard automation workflows just aren't built for this complexity. They're designed for efficiency, not empathy. And that's the gap we need to bridge in 2026.
Building a Compassionate Automation Framework
So what would a better system look like? I've been thinking about this since I first had to perform this task years ago, and I've implemented what I call "compassionate automation" in several organizations since. It's not about removing the human element—it's about automating the technical burden so humans can focus on what matters.
The core idea is simple: create a dedicated workflow for this specific scenario that acknowledges its unique nature. Here's how it might work:
First, you need a trigger that's separate from your standard termination workflows. This could be a specific form in your IT service management system, a dedicated Slack command that requires multiple approvals, or even a physical token system if you want an extra layer of gravity. The key is that initiating this workflow should feel different—because it is different.
Once triggered, the automation should handle the technical tasks in stages rather than all at once. Immediate actions might include disabling login capabilities and changing passwords. But other actions—like archiving emails, preserving file access for the team, or updating distribution lists—might happen on a delayed schedule.
I've found that a 7-30-90 day approach works well. Critical access gets revoked immediately (day 0-7). Team access to files and projects gets preserved but monitored (day 8-30). Full archival and cleanup happens later (day 31-90). This gives everyone time to adjust while still maintaining security.
Technical Implementation with Modern Tools
Let's get practical. How do you actually build this in 2026? Most organizations already have the building blocks—they're just not configured for this specific use case.
Your identity provider (whether it's Azure AD, Okta, or something else) likely supports custom workflows. You can create a specific "bereavement" workflow that triggers different actions than standard deprovisioning. Instead of immediately deleting accounts, it might move them to a special OU in Active Directory or apply specific tags in your cloud identity system.
For email and communications, tools like Microsoft 365 and Google Workspace have retention policies that can be applied conditionally. You can set up a policy that says: "When this specific label is applied, preserve all content for one year, then archive permanently." This ensures nothing is lost while giving the organization time to decide what to keep.
Code repositories like GitHub, GitLab, or Bitbucket have their own considerations. You don't want to delete someone's contributions, but you might want to transfer ownership of repositories or update commit attribution. Some teams create a "memorial" branch or tag important contributions made by the deceased colleague.
The tricky part is connecting all these systems together. That's where workflow automation platforms come in. You can use tools like Zapier, Make, or even custom scripts to coordinate actions across multiple systems. The goal isn't to eliminate human oversight—it's to reduce the number of manual, repetitive tasks that add emotional weight to an already difficult situation.
The Human Element: What Automation Can't Replace
Here's the uncomfortable truth: no amount of automation will make this task easy. And it shouldn't. The discomfort we feel when performing these actions is a reminder of the human behind the account—and that's important.
What automation can do is handle the repetitive, technical tasks so you can focus on the human considerations. Instead of spending an hour manually disabling accounts across 20 different systems, you can spend that time:
- Consulting with the deceased's team about what needs to be preserved
- Creating a proper archive of their work and contributions
- Documenting processes only they knew
- Simply being present with colleagues who are grieving
One sysadmin in the Reddit thread mentioned creating a "digital memorial"—a secure archive of the person's work, emails to the team about their passing, and any other digital artifacts that might be meaningful. This wasn't part of any official process, but it felt right. And that's the kind of human touch that no automation can replicate.
Another consideration: notifications. When you disable an account, automated systems might start sending alerts. "So-and-so hasn't logged in for 14 days." "Password expiration warning for account X." These automated reminders can be painful for teammates who see them. Your automation should include suppressing these notifications for a period or redirecting them to a manager or HR instead.
Legal and Compliance Considerations
This isn't just about feelings—there are real legal and compliance issues at play. Different jurisdictions have different requirements about data retention after death. Some industries have specific regulations about preserving work records. And there's always the question of intellectual property.
In my experience, most organizations haven't thought this through until they have to. That's a problem. Your automation workflows should be built with these considerations in mind from the start.
For example, in healthcare or finance, you might need to preserve certain communications for regulatory reasons. In creative industries, you might need to maintain access to source files for ongoing projects. Your automation should be flexible enough to handle these different requirements based on department, role, or other factors.
It's also worth considering data privacy laws. In some regions, the deceased's personal data has specific protections. Your automation should include steps to identify and properly handle personal versus professional data. This might mean automatically quarantining personal files from work accounts or applying different retention policies to different data types.
Honestly? This is where having a documented process—even if it's partially manual—beats winging it every time. Work with your legal and HR teams to create guidelines, then build your automation around those guidelines.
Practical Steps for Implementation in 2026
Ready to implement something like this in your organization? Here's a practical roadmap based on what I've seen work:
First, have the conversation before you need it. Talk to HR, legal, and leadership about creating a compassionate offboarding process. Frame it not as an IT problem, but as an organizational responsibility. You'll likely find that others have been thinking about this too—they just didn't know who to talk to about it.
Second, document the current state. What happens today when an employee passes away? Who gets notified? What systems are affected? What's the timeline? You can't automate what you don't understand.
Third, design the ideal workflow. This should be a cross-functional effort involving IT, HR, legal, and department heads. Focus on both the technical steps and the human considerations. What information does the team need? What should be preserved? What notifications should be sent (or suppressed)?
Fourth, build the automation incrementally. Start with the most painful, repetitive tasks—like disabling accounts across multiple systems. Use tools you already have. Many identity management systems have APIs that can be called from workflow automation platforms. If you need to gather data from various sources to make decisions, consider using a tool like Apify to systematically collect information from different systems before taking action.
Fifth, test. No, you can't test the actual scenario, but you can test the technical components. Create a test account and run through the workflow. Make sure notifications go to the right places. Verify that data is preserved appropriately. Adjust as needed.
Finally, communicate the process. Let people know it exists. Include it in manager training. The goal isn't to be morbid—it's to be prepared. When the unthinkable happens, having a clear, compassionate process in place is one less thing for everyone to worry about.
Common Mistakes and How to Avoid Them
I've seen organizations get this wrong in several ways. Here are the most common pitfalls:
Moving too fast. The urge to "get it over with" is understandable, but rushing can mean losing important data or causing unnecessary pain. Build delays into your automation. Give people time.
Moving too slow. On the flip side, leaving accounts active indefinitely can be equally problematic. It's a security risk, and it can be painful for teammates who keep seeing the account in systems. Your automation should include clear timelines with appropriate approvals for extensions if needed.
Treating it like any other termination. This is the biggest mistake. The emotional context matters. The notifications matter. The way you talk about it matters. Your automation should reflect that difference.
Forgetting about external systems. It's easy to remember Active Directory and email. It's harder to remember the SaaS tool that department started using last month, or the vendor portal only this person accessed. Your automation should include a discovery phase—checking access logs, expense reports, or other indicators of what systems might be involved. If you don't have good discovery tools internally, sometimes bringing in external expertise can help. I've seen teams successfully hire specialists on Fiverr to audit system access when internal resources are stretched thin.
Ignoring the team's needs. The deceased's teammates might need access to files, emails, or systems to continue their work. Your automation should include steps to identify what's needed and provide appropriate access—without giving everyone full access to everything.
The Bigger Picture: Automation with Empathy
As we move further into 2026, the conversation around automation needs to evolve. It's not just about efficiency anymore—it's about designing systems that acknowledge human realities. The sysadmin who posted on Reddit wasn't complaining about the technical difficulty of disabling accounts. They were expressing the emotional weight of that task.
Our automation should lighten that weight, not ignore it. By building systems that handle the technical complexity with sensitivity, we free ourselves to focus on what really matters: supporting each other through difficult times.
The best automation doesn't remove humans from the process—it removes the parts that make us feel less human. When we automate with empathy, we create systems that aren't just efficient, but are actually better for the people who use them and the people who maintain them.
So take a look at your offboarding processes. Talk to your team. Start building systems that handle not just the expected, but the unexpected. The difficult. The human. Because someday, someone will be grateful you did.
