Customer onboarding is a critical process, often involving a series of steps from data collection and verification to personalized communication and service activation. Manually managing these complex, multi-stage workflows can be time-consuming and prone to errors. Imagine automating large parts of this process using intelligent, autonomous agents. With Services-as-Software on the .do platform, you can.
Services-as-Software: Packaging Intelligence as Reusable Components
At its heart, a Service-as-Software (.do Service) is a self-contained, intelligent agentic workflow that's packaged and exposed as a simple, reusable software component. Think of it as encapsulating a complex process or piece of logic into a callable function or API endpoint that other applications can readily consume.
Instead of building monolithic applications that handle every single step of customer onboarding internally, you can break down the process into smaller, independent services. Each service can represent a specific step or decision point in the workflow, powered by agentic capabilities.
Example: An Onboarding Validation Service
Consider a "Customer Validation" service. This service could take a new customer's information as input. Internally, it might use various agents to:
This entire complex process is abstracted away behind a simple API call. Your main application just invokes the "Customer Validation" service, provides the customer data, and receives the validation result.
Building and Using Services-as-Software on the .do Platform
The .do platform provides the tools and environment to build these intelligent services. You can define your agentic workflows, specify inputs and outputs, manage state like onboarding progress, and secure access to your services. Once defined, you publish your workflow as a Service-as-Software, making it instantly available for consumption via a dedicated API endpoint or using the official .do SDK.
Let's look at a simplified code example using the .do SDK in TypeScript:
import { DoClient } from '@dotdo/sdk';
async function onboardCustomer(customerData: any) {
const client = new DoClient({ apiKey: 'YOUR_API_KEY' });
try {
// Call a 'CustomerValidation' service
const validationResult = await client.services.call('myAccount.customerValidationService', { customerInfo: customerData });
console.log('Customer validation result:', validationResult);
if (validationResult.isValid) {
// If valid, call a 'SendWelcomeEmail' service
const emailResult = await client.services.call('myAccount.sendWelcomeEmailService', { customerId: customerData.id, personalizationData: validationResult.personalization });
console.log('Welcome email sent:', emailResult);
} else {
console.warn('Customer validation failed. No welcome email sent.');
// Potentially call another service to handle invalid customers
}
return validationResult; // Or return a combined result
} catch (error) {
console.error('Error during customer onboarding:', error);
throw error;
}
}
// Example usage:
obboardCustomer({ id: 123, name: 'John Doe', email: 'john.doe@example.com' });
In this example, onboardCustomer orchestrates calls to two distinct .do Services: myAccount.customerValidationService and myAccount.sendWelcomeEmailService. Each service encapsulates a specific, potentially complex, agentic task.
Benefits for Developers and Businesses
Building and consuming Services-as-Software for workflows like customer onboarding offers several advantages:
Transform Your Workflows Today
By embracing the Services-as-Software paradigm on the .do platform, you can transform complex workflows like customer onboarding into streamlined, automated, and intelligent processes. Start building and consuming reusable agentic services to accelerate development and power your projects with advanced capabilities.
Ready to get started? Dive into the .do platform and explore the possibilities of building and integrating Services-as-Software into your applications.