# Orchestrate Microservices Without the Complexity

> Built-in service mesh with automatic discovery, intelligent routing, and distributed tracing across all services. Deploy multiple services that communicate seamlessly with <5ms inter-service latency, automatic failover, and coordinated rollouts. Zero Kubernetes, zero configuration, pure TypeScript across 300+ global edge locations.

Canonical: https://services.do/

## In code

```ts
import { Services } from 'services.do'

// Orchestrate microservices with service mesh
const platform = Services({
  services: {
    api: { port: 8080, public: true },
    auth: { port: 8081, internal: true },
    payments: { port: 8082, internal: true }
  },
  mesh: { tracing: true, retries: 3, timeout: '5s' }
})

// Services communicate automatically
platform.api.on.POST('/orders', async $ => {
  const user = await $.Auth.verify.Token($.headers.authorization)
  const charge = await $.Payments.charge({ amount: $.total, customerId: user.id })
  return $.Database.insert.Order({ userId: user.id, chargeId: charge.id })
})
```

## Frequently asked questions

### How does service discovery work?

Automatic service registration and discovery with zero configuration. Services find each other by name using semantic patterns ($.OtherService.method). Built-in DNS resolution, health checking, and automatic removal of unhealthy instances. Services can communicate across regions with intelligent routing to nearest healthy instance.

### What about inter-service security?

Mutual TLS (mTLS) encryption for all service-to-service communication. Automatic certificate generation, rotation, and validation. Service-level authentication with JWT tokens or API keys. Fine-grained authorization policies control which services can call which endpoints.

### How do I handle distributed transactions?

Built-in saga pattern for coordinating multi-service transactions with automatic compensation on failure. Two-phase commit support for ACID guarantees when needed. Event-driven choreography for loosely coupled services. Full transaction tracing shows exactly what happened across all services.

### Can I do canary deployments and blue-green releases?

Yes. Route percentage of traffic to new versions for testing. Automatic rollback if error rates spike or latency increases. Coordinated deployments across dependent services. Feature flags control which services use new vs old versions of dependencies.

### How does monitoring work across services?

Distributed tracing automatically follows requests across all services with unique trace IDs. Real-time service mesh dashboard shows latency, error rates, and dependency graphs. Aggregate metrics across services or drill into individual service performance. Automatic anomaly detection alerts for degraded services.

## Part of Platform.do

services.do is one of the primitives of Platform.do, in the Business layer (goals, plans and the work itself). Every .do shares one grammar, Business-as-Code, and one SDK.

- What is Business-as-Code? https://platform.do/business-as-code
- Platform.do: https://platform.do/
- Docs: https://docs.platform.do