In the rapidly evolving world of software development, the quest for efficiency, modularity, and reusability is constant. While microservices have paved the way for breaking down large applications, there's a growing need to encapsulate intelligent, autonomous workflows into easily consumable components. Enter Services-as-Software, the core concept powering the .do platform.
At its heart, the .do platform empowers developers to transform complex agentic workflows into simple, reusable software services, accessible via standard APIs and SDKs. Think of it as packaging "business-as-code" – creating self-contained units of intelligent logic that can be seamlessly integrated into any application.
Services-as-Software, or .do Services, are essentially self-contained, intelligent agentic workflows that have been packaged and exposed as readily callable software components. Imagine a sophisticated process involving data retrieval, analysis, decision-making by an AI agent, and action execution. On the .do platform, you can design this entire workflow and publish it as a single, reusable service.
This approach moves beyond simple data APIs. .do Services are designed to handle state, orchestrate multiple steps, and incorporate artificial intelligence or other complex logic directly within the service. They become building blocks for more sophisticated applications, abstracting away the internal complexity and providing a clear, well-defined interface for interaction.
The .do platform provides a comprehensive environment tailored for building these intelligent services. Developers can define their agentic workflows using intuitive tools, specifying inputs, outputs, state management, and security protocols.
Once a workflow is defined, the platform handles the complexities of packaging it as a Service-as-Software. This makes the service available for consumption via its dedicated API endpoint or through the official .do SDKs. This process streamlines the transition from a workflow definition to a deployable, callable service.
Integrating .do Services into your existing applications is designed to be straightforward. Because they're exposed via standard RESTful APIs, you can consume them using any language or framework that supports API calls. For an even smoother development experience, the .do platform offers official SDKs for various programming languages (like the TypeScript example shown below).
This flexibility means you can easily embed powerful agentic capabilities into your existing software projects without needing to reinvent the wheel or manage the underlying complexity of the workflow itself.
This code snippet demonstrates how simple it is to call a .do Service using the TypeScript SDK. With just a few lines of code, you can trigger a complex, intelligent workflow and receive the results.
For developers, building and consuming Services-as-Software on the .do platform offers significant advantages:
By embracing Services-as-Software, developers can accelerate their development cycles, build more robust and scalable applications, and easily incorporate cutting-edge agentic capabilities into their projects.
The .do platform and its focus on Services-as-Software represent a powerful paradigm shift in how we build and consume intelligent functionalities. By providing developers with the tools to easily build, package, and integrate agentic workflows as reusable software components, the platform empowers innovation and unlocks new possibilities for creating sophisticated, intelligent applications.
Ready to start building and using Services-as-Software? Explore the developer tools and APIs available on the .do platform and experience the power of packaging intelligent workflows as simple, reusable software services.
import { DoClient } from '@dotdo/sdk';
async function processData(data: any) {
const client = new DoClient({ apiKey: 'YOUR_API_KEY' });
try {
const serviceResult = await client.services.call('myAccount.processDataService', { inputData: data });
console.log('Service executed successfully:', serviceResult);
return serviceResult;
} catch (error) {
console.error('Error calling service:', error);
throw error;
}
}
// Example usage:
processData({ id: 1, value: 'sample' });