Getting Started

Building Patterns


Now that you understand the concepts, let's build real systems.

Installation & Setup

First, let's get Orcher integrated into your application.

Step 1: Add dependencies

1
[dependencies]
2
orcher = "0.1"
3
tokio = { version = "1", features = ["full"] }
4
serde = { version = "1", features = ["derive"] }

Step 2: Connect to the Orcher server

Create a main.rs that connects to the orchestrator via gRPC:

1
use orcher::prelude::*;
2
3
#[tokio::main]
4
async fn main() -> Result<()> {
5
// Build a worker that connects to the Orcher server
6
let worker = Worker::builder()
7
.server_url("http://localhost:50051")
8
.task_queue("orders")
9
.build()
10
.await?;
11
12
// Run the worker (blocks until shutdown)
13
worker.run().await?;
14
15
Ok(())
16
}

What's happening here:

  1. Server connection: The SDK connects to the Orcher server via gRPC
  2. Task queue: Workers poll the specified task queue for pending work
  3. Worker loop: The worker polls for pending workflows and tasks and executes them

Important: The Orcher server manages workflow state and dispatching. Workers connect to the server and execute workflows and tasks. You can scale workers independently by running multiple instances.

Pattern 1: Reliable Payment Processing

Let's build a payment system that survives a crash mid-payment without losing track of the money or charging twice.

The Problem We're Solving

Payment processing is high-stakes:

  • Lose a charge: Company loses revenue
  • Double-charge: Customer complaints, chargebacks, reputation damage
  • Partial completion: Charge succeeded but email failed → customer confusion
  • Fraud not checked: Financial liability

Traditional code is brittle:

1
// Traditional approach (FRAGILE!)
2
async function processPayment(payment) {
3
const charge = await stripe.charges.create({ amount: payment.amount });
4
await db.payments.insert({ chargeId: charge.id });
5
await sendEmail({ template: 'receipt', to: payment.email });
6
// If server crashes here, email is lost forever
7
await updateUserCredits(payment.userId, payment.amount);
8
}

Problems:

  • No automatic retry
  • No idempotency
  • No visibility into failures
  • Manual debugging required

The Orcher Solution: Step by Step

Let's build this properly. We'll break it into phases:

Phase 1: The Workflow Structure

First, understand the flow. Every step is a checkpoint, and step 2 can branch to an early rejection:

The Payment Workflow
1
validate_payment_method
2
check_fraudfraud_score > 0.8 → reject & stop
3
charge_cardStripe — the point of no return
4
record_payment
5
send_receipt
6
update_credits
7
return success
Every arrow is a potential failure point — and every step a journaled checkpoint.

Phase 2: Define Data Types

1
use serde::{Deserialize, Serialize};
2
3
#[derive(Debug, Serialize, Deserialize)]
4
pub struct PaymentInput {
5
pub user_id: String,
6
pub amount: i64, // Amount in cents
7
pub currency: String,
8
pub payment_method: String, // Stripe payment method ID
9
}
10
11
#[derive(Debug, Serialize, Deserialize)]
12
pub struct PaymentResult {
13
pub charge_id: String,
14
pub status: String,
15
pub receipt_url: String,
16
}

Phase 3: The Workflow

Now the orchestration logic:

1
use orcher::prelude::*;
2
3
#[workflow(name = "process_payment")]
4
pub async fn process_payment(
5
ctx: WorkflowContext,
6
input: PaymentInput,
7
) -> Result<PaymentResult> {
8
// Step 1: Validate (fast, local check)
9
ctx.execute_task(validate_payment_method, input.payment_method.clone())
10
.await?;
11
12
// Step 2: Fraud check (external API)
13
let fraud_score: f64 = ctx.execute_task(check_fraud, (
14
input.user_id.clone(),
15
input.amount,
16
)).await?;
17
18
// Decision logic in the workflow
19
if fraud_score > 0.8 {
20
return Err(anyhow::anyhow!("Payment flagged for fraud"));
21
}
22
23
// Step 3: Charge card (idempotent via Stripe idempotency key)
24
let charge: StripeCharge = ctx.execute_task(charge_stripe, (
25
input.payment_method.clone(),
26
input.amount,
27
input.currency.clone(),
28
)).await?;
29
30
// Step 4: Record in database
31
ctx.execute_task(record_payment, PaymentRecord {
32
user_id: input.user_id.clone(),
33
charge_id: charge.id.clone(),
34
amount: input.amount,
35
status: "succeeded".to_string(),
36
}).await?;
37
38
// Step 5: Send email (idempotent - won't send twice)
39
ctx.execute_task(send_receipt_email, (
40
input.user_id.clone(),
41
charge.receipt_url.clone(),
42
)).await?;
43
44
// Step 6: Update credits
45
ctx.execute_task(update_user_credits, (
46
input.user_id.clone(),
47
input.amount,
48
)).await?;
49
50
Ok(PaymentResult {
51
charge_id: charge.id,
52
status: "succeeded".to_string(),
53
receipt_url: charge.receipt_url,
54
})
55
}

What makes this reliable:

  1. Each ctx.execute_task() is checkpointed: If the workflow crashes, it resumes from the last checkpoint
  2. Idempotent by design: Each task can be safely retried
  3. Decision logic isolated: The workflow controls the flow, tasks do the work
  4. Clear error boundaries: Any error stops the workflow; it can be retried later

Phase 4: Implementing Tasks

Now the individual task implementations. Notice how each task is focused and idempotent:

1
#[task]
2
async fn validate_payment_method(method: String) -> Result<()> {
3
// Validate format only (no external calls)
4
if !method.starts_with("pm_") && !method.starts_with("card_") {
5
return Err(anyhow::anyhow!("Invalid payment method format"));
6
}
7
Ok(())
8
}
9
10
#[task]
11
async fn check_fraud(user_id: String, amount: i64) -> Result<f64> {
12
// Call fraud detection service
13
let response = reqwest::Client::new()
14
.post("https://fraud-api.example.com/check")
15
.json(&serde_json::json!({
16
"user_id": user_id,
17
"amount": amount,
18
}))
19
.send()
20
.await?;
21
22
let score = response.json::<serde_json::Value>().await?["score"]
23
.as_f64()
24
.unwrap_or(0.0);
25
26
Ok(score)
27
}
28
29
#[task]
30
async fn charge_stripe(
31
payment_method: String,
32
amount: i64,
33
currency: String,
34
) -> Result<StripeCharge> {
35
let stripe_key = std::env::var("STRIPE_SECRET_KEY")?;
36
37
// Stripe's idempotency is built-in via their API
38
let response = reqwest::Client::new()
39
.post("https://api.stripe.com/v1/charges")
40
.header("Authorization", format!("Bearer {}", stripe_key))
41
.form(&[
42
("amount", amount.to_string()),
43
("currency", currency),
44
("payment_method", payment_method),
45
("confirm", "true".to_string()),
46
])
47
.send()
48
.await?;
49
50
if !response.status().is_success() {
51
return Err(anyhow::anyhow!("Stripe charge failed"));
52
}
53
54
let charge: StripeCharge = response.json().await?;
55
Ok(charge)
56
}
57
58
#[task]
59
async fn record_payment(record: PaymentRecord) -> Result<()> {
60
let pool = get_db_pool();
61
62
// Idempotent: ON CONFLICT DO NOTHING
63
sqlx::query!(
64
r#"
65
INSERT INTO payments (user_id, charge_id, amount, status, created_at)
66
VALUES ($1, $2, $3, $4, NOW())
67
ON CONFLICT (charge_id) DO NOTHING
68
"#,
69
record.user_id,
70
record.charge_id,
71
record.amount,
72
record.status,
73
)
74
.execute(&pool)
75
.await?;
76
77
Ok(())
78
}
79
80
#[task]
81
async fn send_receipt_email(user_id: String, receipt_url: String) -> Result<()> {
82
// Get user email
83
let pool = get_db_pool();
84
let user: User = sqlx::query_as!(
85
User,
86
"SELECT email FROM users WHERE id = $1",
87
user_id
88
)
89
.fetch_one(&pool)
90
.await?;
91
92
// Send via email service (idempotent - they deduplicate)
93
let sendgrid_key = std::env::var("SENDGRID_API_KEY")?;
94
95
reqwest::Client::new()
96
.post("https://api.sendgrid.com/v3/mail/send")
97
.header("Authorization", format!("Bearer {}", sendgrid_key))
98
.json(&serde_json::json!({
99
"personalizations": [{
100
"to": [{"email": user.email}],
101
}],
102
"from": {"email": "receipts@example.com"},
103
"subject": "Payment Receipt",
104
"content": [{
105
"type": "text/html",
106
"value": format!(
107
"Your payment was successful. <a href='{}'>View Receipt</a>",
108
receipt_url
109
),
110
}],
111
}))
112
.send()
113
.await?;
114
115
Ok(())
116
}
117
118
#[task]
119
async fn update_user_credits(user_id: String, amount: i64) -> Result<()> {
120
let pool = get_db_pool();
121
let credits = amount / 100; // Convert cents to credits
122
123
// Idempotent: adds credits (not set)
124
sqlx::query!(
125
"UPDATE users SET credits = credits + $1 WHERE id = $2",
126
credits,
127
user_id
128
)
129
.execute(&pool)
130
.await?;
131
132
Ok(())
133
}
134
135
// Helper types
136
#[derive(Debug, Serialize, Deserialize)]
137
struct StripeCharge {
138
id: String,
139
receipt_url: String,
140
}
141
142
#[derive(Debug, Serialize, Deserialize)]
143
struct PaymentRecord {
144
user_id: String,
145
charge_id: String,
146
amount: i64,
147
status: String,
148
}
149
150
#[derive(sqlx::FromRow)]
151
struct User {
152
email: String,
153
}
154
155
fn get_db_pool() -> sqlx::PgPool {
156
// Return from your app context
157
todo!("Get pool from application state")
158
}

Key Design Decisions:

  1. validate_payment_method: No external calls, fast validation
  2. check_fraud: External API call, but cached on replay
  3. charge_stripe: Stripe handles idempotency for us
  4. record_payment: ON CONFLICT DO NOTHING makes it idempotent
  5. send_receipt_email: Email service deduplicates
  6. update_user_credits: Uses += not =, so it's additive and safe

Testing the Payment Flow

Let's see what happens in different scenarios:

Scenario 1 · happy path
User submits payment → API starts workflow → worker executes:
1 · validate_payment_method
2 · check_fraud score 0.2
3 · charge_stripe ch_abc
4 · record_payment
5 · send_receipt_email
6 · update_user_credits
Workflow completes → user sees success
Scenario 2 · email service down
User submits payment → worker executes:
1 · validate_payment_method
2 · check_fraud
3 · charge_stripe
4 · record_payment
5 · send_receipt_email — timeout
Workflow fails → scheduled for retry in 1s
Retry #1:
1–4 · cached — no duplicate Stripe charge
5 · send_receipt_email — email service recovered
6 · update_user_credits
Workflow completes → recovery never sends the email again
Scenario 3 · server crashes
User submits payment → worker executes:
1 · validate_payment_method
2 · check_fraud
3 · charge_stripe
4 · record_payment
💥 Server crashes — power outage
10 minutes later, server restarts → worker picks up the pending workflow:
1–4 · cached from journal
5 · send_receipt_email
6 · update_user_credits
Workflow completes → no data loss
Scenario 4 · fraud detected
User submits payment → worker executes:
1 · validate_payment_method
2 · check_fraud score 0.95
3 · workflow throws — “payment flagged for fraud”
Completes with error status → no charge made → user notified

Why This Is Better

Compare to traditional approaches:

Traditional:

  • 200 lines of error handling
  • Redis for state management
  • Manual retry queues
  • Hope you got the idempotency logic right
  • Debugging requires checking 5 different systems
  • Testing requires mocking everything

Orcher:

  • 100 lines of business logic
  • No manual state management
  • Automatic retries
  • Completed steps never repeated on recovery
  • Debugging: just query the journal table
  • Testing: mock individual tasks easily

Pattern 2: Webhook Processing

Webhooks are notoriously tricky. Let's build a reliable webhook handler.

The Webhook Problem

External services (Stripe, Twilio, GitHub, etc.) send HTTP requests to your server when events occur. Problems:

  1. Duplicate webhooks: Services retry on timeout, you process twice
  2. Out-of-order delivery: Event A arrives after Event B
  3. Lost webhooks: Your server is down, webhook is lost forever
  4. Slow processing: Webhook times out, service retries, you process twice
  5. No visibility: Did we process this webhook? What happened?

Traditional approach:

1
// Traditional (FRAGILE!)
2
app.post('/webhooks/stripe', async (req, res) => {
3
const event = req.body;
4
5
// Quick check for duplicate
6
const exists = await redis.get('webhook:' + event.id);
7
if (exists) {
8
return res.json({ received: true });
9
}
10
11
// Process synchronously (blocks response)
12
try {
13
await processEvent(event);
14
await redis.set('webhook:' + event.id, 'processed', 'EX', 86400);
15
res.json({ received: true });
16
} catch (error) {
17
// Error - but webhook service already timed out
18
// Will retry and we'll process twice!
19
res.status(500).json({ error: error.message });
20
}
21
});

Problems:

  • Synchronous processing (slow response)
  • Redis dependency for deduplication
  • If Redis is down, duplicate processing
  • If processing is slow, webhook times out
  • No automatic retries on failure

The Orcher Solution

With Orcher, webhooks become trivial:

Step 1: Receive and Queue

1
use axum::{Json, Extension, http::StatusCode};
2
3
pub async fn handle_stripe_webhook(
4
Extension(orcher): Extension<Orcher>,
5
Json(event): Json<StripeWebhookEvent>,
6
) -> Result<Json<serde_json::Value>, StatusCode> {
7
// Start workflow asynchronously (non-blocking)
8
let workflow_id = orcher
9
.start_workflow("stripe_webhook_processor", event)
10
.await
11
.map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
12
13
// Return immediately - webhook processed in background
14
Ok(Json(serde_json::json!({
15
"received": true,
16
"workflow_id": workflow_id
17
})))
18
}

Key insight: The API handler returns immediately. Processing happens in the background worker. This keeps responses fast.

Step 2: The Processing Workflow

1
#[workflow(name = "stripe_webhook_processor")]
2
pub async fn stripe_webhook_processor(
3
ctx: WorkflowContext,
4
event: StripeWebhookEvent,
5
) -> Result<()> {
6
// Step 1: Verify webhook signature
7
ctx.execute_task(verify_stripe_signature, event.id.clone())
8
.await?;
9
10
// Step 2: Check for duplicate (idempotent)
11
let is_duplicate: bool = ctx.execute_task(check_duplicate, event.id.clone())
12
.await?;
13
14
if is_duplicate {
15
// Already processed - this is a retry from Stripe
16
return Ok(());
17
}
18
19
// Step 3: Route to appropriate handler
20
match event.event_type.as_str() {
21
"charge.succeeded" => {
22
ctx.execute_task(handle_charge_succeeded, event.data).await?;
23
}
24
"charge.failed" => {
25
ctx.execute_task(handle_charge_failed, event.data).await?;
26
}
27
"customer.subscription.updated" => {
28
ctx.execute_task(handle_subscription_updated, event.data).await?;
29
}
30
_ => {
31
ctx.execute_task(log_unknown_event, event.event_type).await?;
32
}
33
}
34
35
// Step 4: Mark as processed
36
ctx.execute_task(mark_event_processed, event.id).await?;
37
38
Ok(())
39
}

Step 3: Task Implementations

1
#[task]
2
async fn check_duplicate(event_id: String) -> Result<bool> {
3
let pool = get_db_pool();
4
5
let result = sqlx::query!(
6
"SELECT COUNT(*) as count FROM processed_webhooks WHERE event_id = $1",
7
event_id
8
)
9
.fetch_one(&pool)
10
.await?;
11
12
Ok(result.count.unwrap_or(0) > 0)
13
}
14
15
#[task]
16
async fn handle_charge_succeeded(data: serde_json::Value) -> Result<()> {
17
let charge_id = data["object"]["id"].as_str().unwrap();
18
let customer_id = data["object"]["customer"].as_str().unwrap();
19
20
let pool = get_db_pool();
21
22
// Update order status
23
sqlx::query!(
24
"UPDATE orders SET status = 'paid', payment_id = $1 WHERE customer_id = $2",
25
charge_id,
26
customer_id
27
)
28
.execute(&pool)
29
.await?;
30
31
// Send confirmation
32
send_order_confirmation(customer_id, charge_id).await?;
33
34
Ok(())
35
}
36
37
#[task]
38
async fn mark_event_processed(event_id: String) -> Result<()> {
39
let pool = get_db_pool();
40
41
sqlx::query!(
42
"INSERT INTO processed_webhooks (event_id, processed_at) VALUES ($1, NOW())",
43
event_id
44
)
45
.execute(&pool)
46
.await?;
47
48
Ok(())
49
}

Why This Works

Fast Response:

  • Webhook endpoint returns in under 50ms
  • Stripe won't timeout and retry unnecessarily
  • Processing happens in background

Automatic Deduplication:

  • check_duplicate prevents double-processing
  • Even if Stripe retries, we detect it
  • No Redis needed - PostgreSQL is your deduplication store

Fault Tolerance:

  • If processing fails, workflow retries automatically
  • Each task is idempotent
  • Complete audit trail in journal

Visibility:

  • Query workflow_execution_journal to see what happened
  • Query processed_webhooks to see all events
  • Easy debugging

Pattern 3: Distributed Transactions (Saga Pattern)

Let's build a complex order fulfillment system that spans multiple services.

The Distributed Transaction Problem

Your order flow:

  1. Create order in your database
  2. Reserve inventory (external inventory service)
  3. Charge customer (Stripe)
  4. Trigger fulfillment (external warehouse service)

What if step 3 fails?

  • Order created ✓
  • Inventory reserved ✓
  • Payment failed ✗
  • Fulfillment not triggered ✗

Now you need to:

  • Release the inventory reservation
  • Cancel the order
  • Notify the customer

This is the saga pattern: each step has a compensating action.

The Orcher Saga Implementation

Step 1: Define the Workflow

1
#[workflow(name = "order_fulfillment")]
2
pub async fn order_fulfillment(
3
ctx: WorkflowContext,
4
order: OrderInput,
5
) -> Result<OrderResult> {
6
let total_amount = order.items.iter()
7
.map(|i| i.price * i.quantity as i64)
8
.sum();
9
10
// Step 1: Create order (compensatable)
11
let order_id: String = ctx.execute_task(create_order, (
12
order.user_id.clone(),
13
order.items.clone(),
14
total_amount,
15
)).await?;
16
17
// Step 2: Reserve inventory (compensatable)
18
let reservation = match ctx.execute_task(
19
reserve_inventory,
20
order.items.clone(),
21
).await {
22
Ok(res) => res,
23
Err(e) => {
24
// Compensate: cancel order
25
ctx.execute_task(cancel_order, order_id.clone()).await?;
26
return Err(e);
27
}
28
};
29
30
// Step 3: Process payment (compensatable)
31
let payment_id = match ctx.execute_task(
32
charge_payment,
33
(order.payment_method.clone(), total_amount),
34
).await {
35
Ok(id) => id,
36
Err(e) => {
37
// Compensate: release inventory and cancel order
38
ctx.execute_task(release_inventory, reservation.id).await?;
39
ctx.execute_task(cancel_order, order_id.clone()).await?;
40
return Err(e);
41
}
42
};
43
44
// Step 4: Confirm order (point of no return)
45
ctx.execute_task(confirm_order, order_id.clone()).await?;
46
47
// Step 5: Trigger fulfillment
48
ctx.execute_task(trigger_fulfillment, (
49
order_id.clone(),
50
reservation.id,
51
)).await?;
52
53
Ok(OrderResult {
54
order_id,
55
status: "confirmed".to_string(),
56
total_amount,
57
})
58
}

Key Points:

  1. Try-Catch Compensation: Each step that can fail has explicit compensation logic
  2. Ordering Matters: Steps are ordered to minimize compensation complexity
  3. Point of No Return: After confirm_order, we don't compensate (customer has been charged)
  4. Automatic Retry: If trigger_fulfillment fails, Orcher retries automatically

Understanding Compensation

Scenario 1: Payment fails — roll back in reverse. The charge is declined before the point of no return, so every completed step is undone by its compensation, newest first.

Payment Declined → Compensate
✓
create_orderorder_123 — journaled
✓
reserve_inventoryreservation_456 — journaled
✗
charge_paymentcard declined
↺
release_inventory(456)compensation — undoes step 2
↺
cancel_order(123)compensation — undoes step 1
=
return errornothing was left half-done

Scenario 2: Fulfillment is down — retry, don't roll back. The failure is after the charge, so undoing isn't an option (the customer paid). Instead the step retries until it succeeds.

Past the Point of No Return → Retry
✓
charge_paymentcustomer charged — journaled
✓
confirm_orderjournaled
✗
trigger_fulfillmentservice unavailable
↻
automatic retrybackoff — no compensation, the charge stands
✓
trigger_fulfillmentsucceeds — workflow completes
The point of no return decides the strategy: compensate before it, retry after it.

Full Task Implementations:

1
#[task]
2
async fn create_order(
3
user_id: String,
4
items: Vec<OrderItem>,
5
total_amount: i64,
6
) -> Result<String> {
7
let pool = get_db_pool();
8
let order_id = uuid::Uuid::new_v4().to_string();
9
10
sqlx::query!(
11
"INSERT INTO orders (id, user_id, total_amount, status) VALUES ($1, $2, $3, 'pending')",
12
order_id, user_id, total_amount
13
)
14
.execute(&pool)
15
.await?;
16
17
// Insert items
18
for item in items {
19
sqlx::query!(
20
"INSERT INTO order_items (order_id, product_id, quantity, price) VALUES ($1, $2, $3, $4)",
21
order_id, item.product_id, item.quantity, item.price
22
)
23
.execute(&pool)
24
.await?;
25
}
26
27
Ok(order_id)
28
}
29
30
#[task]
31
async fn reserve_inventory(items: Vec<OrderItem>) -> Result<InventoryReservation> {
32
let reservation_id = uuid::Uuid::new_v4().to_string();
33
34
// Call inventory service
35
let response = reqwest::Client::new()
36
.post("https://inventory-service.example.com/reserve")
37
.json(&serde_json::json!({
38
"reservation_id": reservation_id,
39
"items": items,
40
}))
41
.send()
42
.await?;
43
44
if !response.status().is_success() {
45
return Err(anyhow::anyhow!("Inventory reservation failed"));
46
}
47
48
Ok(InventoryReservation {
49
id: reservation_id,
50
items: items.into_iter().map(|i| ReservedItem {
51
product_id: i.product_id,
52
quantity: i.quantity,
53
}).collect(),
54
})
55
}
56
57
#[task]
58
async fn charge_payment(payment_method: String, amount: i64) -> Result<String> {
59
let stripe_key = std::env::var("STRIPE_SECRET_KEY")?;
60
61
let response = reqwest::Client::new()
62
.post("https://api.stripe.com/v1/charges")
63
.header("Authorization", format!("Bearer {}", stripe_key))
64
.form(&[
65
("amount", amount.to_string()),
66
("currency", "usd".to_string()),
67
("payment_method", payment_method),
68
("confirm", "true".to_string()),
69
])
70
.send()
71
.await?;
72
73
let charge: serde_json::Value = response.json().await?;
74
Ok(charge["id"].as_str().unwrap().to_string())
75
}
76
77
#[task]
78
async fn confirm_order(order_id: String) -> Result<()> {
79
let pool = get_db_pool();
80
sqlx::query!("UPDATE orders SET status = 'confirmed' WHERE id = $1", order_id)
81
.execute(&pool)
82
.await?;
83
Ok(())
84
}
85
86
#[task]
87
async fn cancel_order(order_id: String) -> Result<()> {
88
let pool = get_db_pool();
89
sqlx::query!("UPDATE orders SET status = 'cancelled' WHERE id = $1", order_id)
90
.execute(&pool)
91
.await?;
92
Ok(())
93
}
94
95
#[task]
96
async fn release_inventory(reservation_id: String) -> Result<()> {
97
reqwest::Client::new()
98
.post("https://inventory-service.example.com/release")
99
.json(&serde_json::json!({"reservation_id": reservation_id}))
100
.send()
101
.await?;
102
Ok(())
103
}
104
105
#[task]
106
async fn trigger_fulfillment(order_id: String, reservation_id: String) -> Result<()> {
107
reqwest::Client::new()
108
.post("https://fulfillment-service.example.com/orders")
109
.json(&serde_json::json!({
110
"order_id": order_id,
111
"reservation_id": reservation_id
112
}))
113
.send()
114
.await?;
115
Ok(())
116
}
117
118
fn get_db_pool() -> sqlx::PgPool {
119
todo!("Get pool from application state")
120
}

The saga pattern in action:

This pattern ensures consistency across distributed services without a distributed transaction coordinator. Each step is compensatable, and Orcher's journaling ensures we never lose track of where we are in the process.


Next Steps