In the modern enterprise, software isn't just a tool; it's the environment. We don't just use services, we build our companies out of them. Slack for communication, Jira for projects, Google Workspace for collaboration, Salesforce for customers—this is the era of Services-as-Software (SaaS).
But this modular, best-of-breed approach introduces a foundational challenge: How do you manage the single most important asset across all these disparate systems? Your people.
Every new service added is another silo, another user list to manage, another set of permissions to configure. Onboarding a new hire becomes a marathon of manual invitations. A promotion triggers a scavenger hunt to update access levels. Offboarding an employee feels like a race against time to plug potential security holes.
The chaos stems from a simple, outdated mental model. We treat our organizational directory as a byproduct, a simple list of names and emails. It's time for a paradigm shift. Your directory isn't just a list; it's the foundational layer upon which your entire service architecture should be built. And it's time to start managing it as code.
Think about the typical workflow for a role change. An engineer, Diana, is promoted to Engineering Manager. What happens next?
Each step is manual, error-prone, and slow. More importantly, there is no single source of truth for "Who is Diana and what should she have access to?" The answer is scattered across a half-dozen platforms, each with its own state. This is not just inefficient; it's a massive security and compliance risk.
What if your entire organizational chart—every user, team, reporting line, and group membership—was defined in a clear, structured format? What if you could manage it just like you manage your infrastructure?
This is the principle behind Directory as Code.
It means treating your organizational directory as a declarative configuration. Instead of manually clicking through UI panels, you define your org structure in code. This code becomes the single source of truth that dictates the state of your user base across every integrated service.
The benefits are immediate and transformative:
This is precisely the problem directory.do was built to solve. We provide a powerful, developer-first API that allows you to manage your entire organizational directory as code.
Instead of a scattered mess, your org structure becomes a clean, readable object. A user isn't just a row in a database; they are a complete entity with defined relationships.
{
"user": {
"id": "usr_1a2b3c4d5e6f7g8h",
"name": "Alice Johnson",
"email": "alice.j@example.com",
"title": "Director of Engineering",
"status": "active",
"manager": {
"id": "usr_9i8j7k6l5m4n3o2p",
"name": "Bob Williams",
"email": "bob.w@example.com",
"title": "CTO"
},
"direct_reports": [
{
"id": "usr_a1b2c3d4e5f6g7h8",
"name": "Charlie Brown",
"email": "charlie.b@example.com",
"title": "Senior Software Engineer"
},
{
"id": "usr_z9y8x7w6v5u4t3s2",
"name": "Diana Prince",
"email": "diana.p@example.com",
"title": "Engineering Manager"
}
],
"groups": [
"engineering-leads",
"all-employees"
]
}
}
This isn't just data. It's a directive.
When you update this structure via the directory.do API, our agentic workflows get to work. These agents are intelligent processes that understand your intent. When Alice's status changes to "inactive," they don't just flip a bit in our database. They reach out to your connected systems—Google Workspace, Azure AD, Okta, Slack—and execute the entire offboarding process, ensuring all access is revoked cleanly and instantly.
When a new user is added to the "direct_reports" array for a manager, agents can automatically trigger an onboarding sequence, creating accounts and assigning them to the correct teams and projects.
In a world composed of Services-as-Software, a coherent identity and access control layer is not optional—it's the bedrock. Without it, you’re building on sand. Each new service adds to the complexity and fragility of your operational security.
By treating your directory as the foundational code layer, you bring order to the chaos. Access control, team structures, and user lifecycles are no longer managed application by application. Instead, they flow from a central, trusted source.
This is more than just a new tool; it's a more resilient, secure, and efficient way to build and run a modern company. Stop chasing user states across dozens of tabs. Define your organization with the clarity and power of code.
Ready to build your organization on a better foundation? Explore directory.do and see how our user management API can transform your workflows.