Automating User Onboarding with the directories.do API

Manually onboarding a new user is a familiar, often tedious, process. It's a checklist of repetitive tasks: create a home folder, provision project directories, set the right permissions, and add them to the correct team shares. This process is not only slow but also prone to human error, leading to inconsistent setups and potential security gaps. What if you could standardize and automate this entire workflow with just a few lines of code?

With the directories.do API, you can. By treating directory structures as a programmable resource, you can turn complex organizational tasks into simple, automated, and scalable workflows. Let's explore how to build a seamless user onboarding process from scratch.

The Challenge: Manual Directory Management Doesn't Scale

For a small team, manual onboarding might seem manageable. But as your organization grows, the cracks begin to show:

• Inconsistency: Different admins might set up folders or permissions slightly differently.
• Human Error: It's easy to forget a step or assign the wrong access level.
• Lack of Speed: The process is a bottleneck, delaying a new hire's ability to be productive.
• Security Risks: Incorrect permissions can expose sensitive data.

The core problem is that traditional directory management is a manual, reactive task. The solution is to make it a proactive, code-driven one.

The Solution: Directory Management, Programmatically

directories.do provides a simple REST API to create, list, query, and manage complex directory structures for your organization, users, or applications. Instead of clicking through a UI, you execute commands. This is the foundation of an agentic workflow, where automated agents handle operational tasks based on triggers and code.

Let's build an automated onboarding script for a new employee, "Jane Doe."

Step 1: Initialize the Service and Create the User Directory

When a new user is created in your HR system, a webhook can trigger a script that uses our API. The first step is to create a primary directory for Jane, complete with essential metadata.

Our code example shows just how straightforward this is:

import { Directories } from '@do-sdk/core';

// Initialize the Directories agent
const directoryService = new Directories();

// Create a new user directory with metadata
const newUserDirectory = await directoryService.create({
  path: '/users/jane.doe/documents',
  metadata: {
    userId: 'user-id-12345',
    team: 'engineering',
    access: ['read', 'write']
  },
  recursive: true // Creates parent directories if they don't exist
});

console.log('Successfully created directory:', newUserDirectory.path);

Let's break down what's happening here:

• path: We define a clean, logical path for the new user's directory.
• metadata: This is where the magic happens. We aren't just creating an empty folder; we're attaching a rich JSON object to it. Here, we've stored Jane's unique ID, her team affiliation, and her base access rights. This metadata makes the directory a powerful, queryable object.
• recursive: true: This is a huge time-saver. You don't need to check if the /users or /users/jane.doe directories already exist. The API handles the creation of the entire parent chain automatically.

Step 2: Leverage Metadata for Granular Access Control

Permissions are no longer buried in a complex ACL panel. With directories.do, access control is managed directly through the metadata you define. Your application can now query a directory's metadata to enforce permissions before granting access.

For example, when Jane tries to access a file, your application can first check the access array in the metadata for her parent directory. This makes implementing role-based access control (RBAC) incredibly simple and transparent.

Step 3: Provisioning a Standard Folder Structure

Jane needs more than just one folder. She needs a standard set of directories for private work, team projects, and company templates. You can easily extend the script to provision this structure with a simple loop.

// (Continuing from the previous example)

const standardFolders = [
  { name: 'private', access: ['full-control'] },
  { name: 'team-projects', access: ['read', 'write'] },
  { name: 'templates', access: ['read-only'] }
];

for (const folder of standardFolders) {
  await directoryService.create({
    path: `/users/jane.doe/documents/${folder.name}`,
    metadata: {
      ...newUserDirectory.metadata, // Inherit base metadata
      access: folder.access // Override with specific permissions
    }
  });
}

console.log('Standard folder structure for Jane Doe has been provisioned.');

In minutes, you've codified your entire onboarding directory policy. Every new user gets the exact same structure with the correct permissions, every single time.

Beyond Onboarding: A Fully Managed Directory Lifecycle

This programmatic approach extends to the entire user lifecycle.

• Changing Roles? Update the metadata on a user's directories to automatically reflect their new team and permissions.
• User Offboarding? A single API call can recursively delete a user's entire directory structure, ensuring a clean and secure offboarding process.
• Auditing? Query all directories with a specific metadata tag (e.g., team: 'engineering') to easily audit permissions and structures.

Why directories.do is Your Solution

directories.do was built to help you ORGANIZE. AUTOMATE. SCALE.

• Flexibility: Manage any hierarchical structure, from user directories and file systems to product catalogs and organizational charts.
• Powerful API: Recursive operations and metadata queries allow you to manage complex structures with single commands.
• Secure by Design: Embed permissions directly as metadata, making access control a core part of your directory data model.
• Custom Metadata: Store any application-specific information you need as a flexible JSON object, turning your directory into an integrated data source.

Ready to stop clicking and start coding? Transform your manual directory operations into a fast, reliable, and scalable automated workflow.

Visit directories.do to dive into our documentation and get your API key today.