Step-by-Step: Building Your First Service-as-Software on service.do

Are you looking to unlock new levels of efficiency and create programmable value for your business? The concept of delivering your core business processes as Services-as-Software (SaaS) is a powerful way to achieve this. Imagine transforming complex operational tasks into simple, API-driven services that can be integrated anywhere.

This is where service.do comes in. We provide the platform to build, deploy, and manage these programmable services, powered by agentic workflows and AI. Instead of manual processes or rigid internal tools, you can create flexible, intelligent agents that handle tasks on demand.

In this post, we'll walk you through the fundamental steps of building your very first Service-as-Software using service.do.

What is Services-as-Software (SaaS) in the service.do Context?

At its core, Service-as-Software on service.do means taking a specific business process (like generating an invoice, onboarding a new user, or processing a payment) and encapsulating it as a programmable unit. This unit is then exposed through easy-to-use APIs and SDKs, allowing other systems or applications to interact with and trigger that process programmatically.

The magic happens under the hood, where service.do utilizes agentic workflows to power these services. An agent acts as an intelligent orchestrator, capable of executing a sequence of predefined actions to achieve the service's objective. These actions can involve fetching data, performing calculations, interacting with external APIs, generating documents, and much more.

Why Deliver Your Services as Software?

Transforming your internal processes into programmable services offers significant advantages:

• Automation: Automate repetitive and time-consuming tasks, freeing up human resources for more strategic work.
• Integration: Easily integrate your services with other internal systems or external partners, creating seamless workflows.
• Scalability: Scale your operations more efficiently as your services can handle increased demand programmatically.
• New Revenue Streams: Offer your business capabilities as a service to customers or partners, creating new business opportunities.
• Improved Efficiency: Streamline processes and reduce errors by replacing manual steps with reliable software interactions.

Building Your First Service-as-Software with service.do: A Simple Example

Let's consider a common business process: generating and sending an invoice based on sales data. We can transform this into a Service-as-Software on service.do.

Here's a conceptual breakdown and how it maps to service.do:

1. Identify the Business Process: Generating and sending an invoice.
2. Define the Steps (Actions):
   • Fetch relevant sales data for a given order.
   • Calculate the total invoice amount based on the data.
   • Generate a PDF document of the invoice.
   • Send the invoice PDF to the customer via email.
3. Create an Agent: On service.do, you define an Agent that will perform these steps. You give it a name and a description.
4. Define the Agent's Actions: You specify the individual actions (like fetchSalesData, calculateInvoiceTotal, generatePdf, sendEmail) that the Agent can perform. These actions represent the discrete steps of your business process.
5. Orchestrate the Workflow: You define the sequence in which the Agent should execute these actions to complete the service (e.g., first fetch data, then calculate, then generate PDF, then send email).
6. Expose as a Service: Service.do automatically exposes your Agent's capabilities and workflows as APIs and SDKs, making your "Generate Invoice" service accessible programmatically.

Here's how this looks in a simplified code snippet using a hypothetical service.do SDK (similar to the example provided on the website):

import { Agent } from '.do';

// Define our Agent named 'InvoiceGenerator'
const serviceAgent = new Agent({
  name: 'InvoiceGenerator',
  description: 'Generates and sends invoices based on sales data.',
  actions: [
    'fetchSalesData',       // Action to get sales data
    'calculateInvoiceTotal',// Action to calculate total
    'generatePdf',          // Action to create the PDF
    'sendEmail'             // Action to send the email
  ]
});

// Define a function that triggers the agentic workflow
async function generateInvoice(orderId: string) {
  // Use the agent to perform actions in sequence
  const invoiceDetails = await serviceAgent.do('fetchSalesData', { orderId });
  const total = await serviceAgent.do('calculateInvoiceTotal', invoiceDetails);
  const pdf = await serviceAgent.do('generatePdf', { ...invoiceDetails, total });
  await serviceAgent.do('sendEmail', { to: invoiceDetails.customerEmail, attachment: pdf });

  return { success: true, message: 'Invoice generated and sent' };
}

// Now you can call generateInvoice(orderId) from any application or system
// to programmatically trigger the invoice generation and sending process.

This code demonstrates how you can orchestrate a business process by telling your InvoiceGenerator agent to perform specific actions in a defined order. The beauty of service.do is that it provides the infrastructure to define these agents, their actions, and expose them as reliable, programmable services.

Key Concepts on service.do

• Agents: The core building blocks representing your programmable services. They are designed to perform specific tasks.
• Actions: The individual, discrete steps that an Agent can execute. These are the fundamental units of work in your service.
• Agentic Workflows: The sequence and logic that an Agent follows to perform a task. This is where you define how the actions are orchestrated.
• APIs and SDKs: The standard interfaces automatically generated by service.do, allowing other systems to interact with your services.

Getting Started with service.do

To build your first Service-as-Software on service.do, you would typically:

1. Sign up or Log in to the service.do platform.
2. Define your Agent: Specify the name, description, and the actions it can perform.
3. Implement the Actions: Write the code or configure integrations for each individual action your agent needs to perform (e.g., connecting to your database to fetch sales data, using a PDF generation library, integrating with your email service).
4. Build the Agentic Workflow: Define the logic and sequence of actions within the service.do interface or through code, depending on the complexity.
5. Deploy Your Service: Deploy your agent and its workflows on the service.do platform.
6. Integrate: Use the generated APIs and SDKs to call your new programmable service from your applications or other systems.

Conclusion

Transforming your business processes into programmable Services-as-Software is a strategic move towards greater efficiency, automation, and integration. service.do provides the platform and the power of agentic workflows to make this transformation achievable. By following the steps outlined above, you can start building your first programmable service and unlock the potential of delivering your business capabilities as software.

Ready to transform your business processes? Explore service.do and start building your first Service-as-Software today!