Building Durable Payment Workflows with Temporal in Go: My Lessons from Engineering a UK Fintech's

User clicks "Send £500"
    → API receives request
    → Validate account
    → Check fraud
    → Debit account
    → Send to core banking
    → Wait for confirmation
    → Credit recipient
    → Send notification

package workflow

import (
	"fmt"
	"time"

	"go.temporal.io/sdk/temporal"
	"go.temporal.io/sdk/workflow"
)

// SEPAPaymentInput contains all data needed to process a SEPA payment
type SEPAPaymentInput struct {
	PaymentID       string
	CustomerID      string
	SourceAccountID string
	DestinationIBAN string
	DestinationBIC  string
	Amount          int64  // Amount in minor units (cents)
	Currency        string // EUR for SEPA
	Reference       string
	BeneficiaryName string
}

// SEPAPaymentOutput is the result of a completed payment
type SEPAPaymentOutput struct {
	PaymentID      string
	Status         string
	TransactionRef string
	CompletedAt    time.Time
}

// SEPAPayment orchestrates the complete payment lifecycle
func SEPAPayment(ctx workflow.Context, input SEPAPaymentInput) (*SEPAPaymentOutput, error) {
	logger := workflow.GetLogger(ctx)
	logger.Info("Starting SEPA payment workflow", "paymentID", input.PaymentID)

	// Configure activity options with sensible defaults
	activityOptions := workflow.ActivityOptions{
		StartToCloseTimeout: 10 * time.Minute,
		RetryPolicy: &temporal.RetryPolicy{
			InitialInterval:    time.Second,
			BackoffCoefficient: 2.0,
			MaximumInterval:    time.Minute,
			MaximumAttempts:    5,
		},
	}
	ctx = workflow.WithActivityOptions(ctx, activityOptions)

	// Step 1: Validate the payment request
	var validationResult ValidationResult
	err := workflow.ExecuteActivity(ctx, ValidatePayment, input).Get(ctx, &validationResult)
	if err != nil {
		return nil, fmt.Errorf("validation failed: %w", err)
	}

	// Step 2: Check if this payment requires approval
	if err := handleApprovalIfRequired(ctx, input); err != nil {
		return nil, err
	}

	// Step 3: Security checks - detect suspicious patterns
	blocked, err := checkSecurityAndBlock(ctx, input)
	if err != nil {
		return nil, err
	}
	if blocked {
		// Wait for manual review - workflow pauses here
		if err := waitForUnblock(ctx); err != nil {
			return nil, err
		}
	}

	// Step 4: Fraud evaluation (single attempt)
	fraudCtx := workflow.WithActivityOptions(ctx, workflow.ActivityOptions{
		StartToCloseTimeout: 30 * time.Second,
		RetryPolicy: &temporal.RetryPolicy{
			MaximumAttempts: 1, // No retries for fraud checks
		},
	})

	var fraudResult FraudCheckResult
	err = workflow.ExecuteActivity(fraudCtx, CheckFraud, input).Get(ctx, &fraudResult)
	if err != nil {
		return nil, fmt.Errorf("fraud check failed: %w", err)
	}

	if fraudResult.Rejected {
		return nil, temporal.NewNonRetryableApplicationError(
			"Payment rejected by fraud system",
			"FRAUD_REJECTED",
			nil,
		)
	}

	// Step 5: Check if user cancelled while we were processing
	if cancelled, _ := isPaymentCancelled(ctx, input.PaymentID); cancelled {
		return nil, temporal.NewNonRetryableApplicationError(
			"Payment cancelled by user",
			"USER_CANCELLED",
			nil,
		)
	}

	// Step 6: Mark payee as trusted for future payments
	_ = workflow.ExecuteActivity(ctx, MarkPayeeAsTrusted, input).Get(ctx, nil)

	// Step 7: Publish to legacy banking system via IBM MQ
	var mqResult MQPublishResult
	err = workflow.ExecuteActivity(ctx, PublishToLegacyBanking, input).Get(ctx, &mqResult)
	if err != nil {
		return nil, fmt.Errorf("failed to publish to legacy system: %w", err)
	}

	// Step 8: Wait for confirmation from legacy system (this is the magic)
	paymentResult, err := waitForLegacyConfirmation(ctx, input.PaymentID)
	if err != nil {
		return nil, err
	}

	logger.Info("SEPA payment completed successfully",
		"paymentID", input.PaymentID,
		"transactionRef", paymentResult.TransactionRef)

	return paymentResult, nil
}

// waitForLegacyConfirmation blocks the workflow until we receive
// a signal from the legacy system (via mq-listener)
func waitForLegacyConfirmation(ctx workflow.Context, paymentID string) (*SEPAPaymentOutput, error) {
	logger := workflow.GetLogger(ctx)

	// Setup signal channels
	paymentSignalChan := workflow.GetSignalChannel(ctx, SignalPaymentResult)
	transactionSignalChan := workflow.GetSignalChannel(ctx, SignalTransactionResult)

	var paymentResult PaymentSignal
	var transactionResult TransactionSignal
	paymentReceived := false
	transactionReceived := false

	// We might receive payment confirmation and transaction confirmation separately
	for !paymentReceived || !transactionReceived {
		selector := workflow.NewSelector(ctx)

		// Handle payment status signal
		selector.AddReceive(paymentSignalChan, func(ch workflow.ReceiveChannel, more bool) {
			ch.Receive(ctx, &paymentResult)
			logger.Info("Received payment signal", "status", paymentResult.Status)
			paymentReceived = true
		})

		// Handle transaction confirmation signal
		selector.AddReceive(transactionSignalChan, func(ch workflow.ReceiveChannel, more bool) {
			ch.Receive(ctx, &transactionResult)
			logger.Info("Received transaction signal", "ref", transactionResult.Reference)
			transactionReceived = true
		})

		// Add timeout - don't wait forever
		timer := workflow.NewTimer(ctx, 7*24*time.Hour) // 7 days max for SWIFT
		selector.AddFuture(timer, func(f workflow.Future) {
			logger.Warn("Payment confirmation timeout", "paymentID", paymentID)
		})

		selector.Select(ctx)

		// Check for errors in received signals
		if paymentReceived && paymentResult.Status == "FAILED" {
			return nil, temporal.NewNonRetryableApplicationError(
				paymentResult.ErrorMessage,
				"LEGACY_REJECTED",
				nil,
			)
		}
	}

	return &SEPAPaymentOutput{
		PaymentID:      paymentID,
		Status:         "COMPLETED",
		TransactionRef: transactionResult.Reference,
		CompletedAt:    workflow.Now(ctx),
	}, nil
}

package transform

import (
	"fmt"
	"strings"
	"time"
)

// LegacyPaymentMessage represents the format expected by the legacy system
type LegacyPaymentMessage struct {
	OLBReference     string // Unique reference we generate
	AccountBranch    string // 6 digits
	AccountBasic     string // 8 digits
	AccountSuffix    string // 3 digits
	PayeeAccountIBAN string
	PayeeBIC         string
	PayeeName        string // 35 chars max
	Amount           string // In minor units, no decimals
	Currency         string
	PaymentDate      string // YYYYMMDD
	Reference1       string // 35 chars max
	Reference2       string // 35 chars max
	Reference3       string // 35 chars max
	IsSEPA           string // Y/N
	ChargeType       string // SHA/OUR/BEN
}

// ToLegacyFormat converts a payment to the legacy tab-delimited format
func ToLegacyFormat(payment SEPAPaymentInput, olbRef string) []byte {
	msg := LegacyPaymentMessage{
		OLBReference:     olbRef,
		AccountBranch:    extractBranch(payment.SourceAccountID),
		AccountBasic:     extractBasic(payment.SourceAccountID),
		AccountSuffix:    extractSuffix(payment.SourceAccountID),
		PayeeAccountIBAN: payment.DestinationIBAN,
		PayeeBIC:         payment.DestinationBIC,
		PayeeName:        truncate(payment.BeneficiaryName, 35),
		Amount:           fmt.Sprintf("%d", payment.Amount),
		Currency:         payment.Currency,
		PaymentDate:      time.Now().Format("20060102"),
		Reference1:       splitReference(payment.Reference, 0),
		Reference2:       splitReference(payment.Reference, 1),
		Reference3:       splitReference(payment.Reference, 2),
		IsSEPA:           "Y",
		ChargeType:       "SHA", // Shared charges for SEPA
	}
	return msg.Encode()
}

// Encode converts the message to tab-delimited legacy format
func (m LegacyPaymentMessage) Encode() []byte {
	fields := []string{
		m.OLBReference,
		m.AccountBranch,
		m.AccountBasic,
		m.AccountSuffix,
		m.PayeeAccountIBAN,
		m.PayeeBIC,
		padRight(m.PayeeName, 35),
		m.Amount,
		m.Currency,
		m.PaymentDate,
		padRight(m.Reference1, 35),
		padRight(m.Reference2, 35),
		padRight(m.Reference3, 35),
		m.IsSEPA,
		m.ChargeType,
	}
	return []byte(strings.Join(fields, "\t"))
}

// splitReference breaks a long reference into 35-char chunks
func splitReference(ref string, index int) string {
	const chunkSize = 35
	start := index * chunkSize
	if start >= len(ref) {
		return ""
	}
	end := start + chunkSize
	if end > len(ref) {
		end = len(ref)
	}
	return ref[start:end]
}

package publisher

import (
	"context"
	"fmt"
	"time"

	"github.com/ibm-messaging/mq-golang/v5/ibmmq"
)

type MQPublisher struct {
	queueManager *ibmmq.MQQueueManager
	queue        ibmmq.MQObject
	config       Config
}

type Config struct {
	Host         string
	Port         int
	QueueManager string
	Channel      string
	Queue        string
	User         string
	Password     string
}

func NewMQPublisher(cfg Config) (*MQPublisher, error) {
	cd := ibmmq.NewMQCD()
	cd.ChannelName = cfg.Channel
	cd.ConnectionName = fmt.Sprintf("%s(%d)", cfg.Host, cfg.Port)

	csp := ibmmq.NewMQCSP()
	csp.AuthenticationType = ibmmq.MQCSP_AUTH_USER_ID_AND_PWD
	csp.UserId = cfg.User
	csp.Password = cfg.Password

	cno := ibmmq.NewMQCNO()
	cno.ClientConn = cd
	cno.SecurityParms = csp
	cno.Options = ibmmq.MQCNO_CLIENT_BINDING

	qMgr, err := ibmmq.Connx(cfg.QueueManager, cno)
	if err != nil {
		return nil, fmt.Errorf("failed to connect to queue manager: %w", err)
	}

	od := ibmmq.NewMQOD()
	od.ObjectType = ibmmq.MQOT_Q
	od.ObjectName = cfg.Queue

	openOptions := ibmmq.MQOO_OUTPUT | ibmmq.MQOO_FAIL_IF_QUIESCING

	queue, err := qMgr.Open(od, openOptions)
	if err != nil {
		qMgr.Disc()
		return nil, fmt.Errorf("failed to open queue: %w", err)
	}

	return &MQPublisher{
		queueManager: &qMgr,
		queue:        queue,
		config:       cfg,
	}, nil
}

// Publish sends a message to the legacy system with retry logic
func (p *MQPublisher) Publish(ctx context.Context, message []byte) error {
	return p.publishWithRetry(ctx, message, 3)
}

func (p *MQPublisher) publishWithRetry(ctx context.Context, message []byte, maxRetries int) error {
	var lastErr error

	for attempt := 0; attempt < maxRetries; attempt++ {
		if attempt > 0 {
			select {
			case <-ctx.Done():
				return ctx.Err()
			case <-time.After(5 * time.Second):
			}
		}

		err := p.put(message)
		if err == nil {
			return nil
		}
		lastErr = err

		// Check if it's a connection error that requires reconnect
		if mqErr, ok := err.(*ibmmq.MQReturn); ok {
			if mqErr.MQRC == ibmmq.MQRC_CONNECTION_BROKEN {
				if reconnectErr := p.reconnect(); reconnectErr != nil {
					return fmt.Errorf("reconnect failed: %w", reconnectErr)
				}
				continue
			}
		}
		return err
	}

	return fmt.Errorf("failed after %d attempts: %w", maxRetries, lastErr)
}

func (p *MQPublisher) put(message []byte) error {
	md := ibmmq.NewMQMD()
	md.Format = ibmmq.MQFMT_STRING

	pmo := ibmmq.NewMQPMO()
	pmo.Options = ibmmq.MQPMO_NO_SYNCPOINT | ibmmq.MQPMO_NEW_MSG_ID

	return p.queue.Put(md, pmo, message)
}

package listener

import (
	"context"
	"fmt"
	"time"

	"github.com/ibm-messaging/mq-golang/v5/ibmmq"
	"go.temporal.io/sdk/client"
)

type MQListener struct {
	queueManager   *ibmmq.MQQueueManager
	queue          ibmmq.MQObject
	temporalClient client.Client
	parser         *MessageParser
}

// Start begins listening for messages from the legacy system
func (l *MQListener) Start(ctx context.Context) error {
	logger := getLogger(ctx)
	logger.Info("Starting MQ listener")

	for {
		select {
		case <-ctx.Done():
			logger.Info("Shutting down MQ listener")
			return nil
		default:
			if err := l.processNextMessage(ctx); err != nil {
				logger.Error("Error processing message", "error", err)
				// Continue listening - don't crash on single message failure
			}
		}
	}
}

func (l *MQListener) processNextMessage(ctx context.Context) error {
	md := ibmmq.NewMQMD()
	gmo := ibmmq.NewMQGMO()
	gmo.Options = ibmmq.MQGMO_WAIT | ibmmq.MQGMO_FAIL_IF_QUIESCING
	gmo.WaitInterval = 10 * 1000 // 10 seconds

	buffer := make([]byte, 32768)
	datalen, err := l.queue.Get(md, gmo, buffer)
	if err != nil {
		if mqErr, ok := err.(*ibmmq.MQReturn); ok {
			if mqErr.MQRC == ibmmq.MQRC_NO_MSG_AVAILABLE {
				return nil // No message, this is normal
			}
		}
		return fmt.Errorf("failed to get message: %w", err)
	}

	message := buffer[:datalen]
	parsed, err := l.parser.Parse(message)
	if err != nil {
		return fmt.Errorf("failed to parse message: %w", err)
	}

	return l.signalWorkflow(ctx, parsed)
}

func (l *MQListener) signalWorkflow(ctx context.Context, msg ParsedMessage) error {
	var signalName string
	var signalData interface{}

	switch msg.Type {
	case MessageTypePaymentResult:
		signalName = "SignalPaymentResult"
		signalData = PaymentSignal{
			Status:       msg.Status,
			ErrorCode:    msg.ErrorCode,
			ErrorMessage: msg.ErrorMessage,
		}
	case MessageTypeTransactionConfirmation:
		signalName = "SignalTransactionResult"
		signalData = TransactionSignal{
			Reference:   msg.TransactionRef,
			CompletedAt: msg.Timestamp,
		}
	default:
		return fmt.Errorf("unknown message type: %s", msg.Type)
	}

	return l.signalWithRetry(ctx, msg.WorkflowID, signalName, signalData)
}

func (l *MQListener) signalWithRetry(ctx context.Context, workflowID, signalName string, data interface{}) error {
	maxRetries := 3

	for attempt := 0; attempt < maxRetries; attempt++ {
		err := l.temporalClient.SignalWorkflow(ctx, workflowID, "", signalName, data)
		if err == nil {
			return nil
		}

		// Check if workflow is already completed - that's OK
		if isWorkflowNotFoundError(err) {
			getLogger(ctx).Warn("Workflow not found, may already be completed",
				"workflowID", workflowID)
			return nil
		}

		if attempt < maxRetries-1 {
			time.Sleep(time.Second * time.Duration(attempt+1))
		}
	}

	return fmt.Errorf("failed to signal workflow after %d attempts", maxRetries)
}

CSV with 500 payments uploaded
    → Payment 1: Success
    → Payment 2: Success
    → ...
    → Payment 247: FAILS (insufficient funds)
    → What happens to payments 1-246?
    → What about 248-500?

package workflow

// BulkPaymentInput represents a batch of payments
type BulkPaymentInput struct {
	BatchID    string
	Payments   []SinglePaymentLine
	UploadedBy string
	UploadedAt time.Time
}

type SinglePaymentLine struct {
	LineNumber  int
	Reference   string
	PaymentData SEPAPaymentInput
}

type BulkPaymentResult struct {
	BatchID     string
	TotalLines  int
	Successful  int
	Failed      int
	FailedLines []FailedLine
}

type FailedLine struct {
	LineNumber int
	Reference  string
	Error      string
}

// BulkPaymentWorkflow processes a batch of payments with compensation
func BulkPaymentWorkflow(ctx workflow.Context, input BulkPaymentInput) (*BulkPaymentResult, error) {
	logger := workflow.GetLogger(ctx)
	logger.Info("Starting bulk payment workflow",
		"batchID", input.BatchID,
		"totalPayments", len(input.Payments))

	activityOptions := workflow.ActivityOptions{
		StartToCloseTimeout: 5 * time.Minute,
		RetryPolicy: &temporal.RetryPolicy{
			InitialInterval:    time.Second,
			BackoffCoefficient: 2.0,
			MaximumInterval:    100 * time.Second,
			MaximumAttempts:    5,
		},
	}
	ctx = workflow.WithActivityOptions(ctx, activityOptions)

	result := &BulkPaymentResult{
		BatchID:     input.BatchID,
		TotalLines:  len(input.Payments),
		FailedLines: []FailedLine{},
	}

	// Process each payment individually
	for _, line := range input.Payments {
		err := processPaymentLine(ctx, input.BatchID, line)
		if err != nil {
			logger.Warn("Payment line failed",
				"lineNumber", line.LineNumber,
				"error", err)

			// Compensate: Mark line as failed so it can be retried later
			compensateErr := compensateFailedLine(ctx, input.BatchID, line)
			if compensateErr != nil {
				logger.Error("Compensation failed",
					"lineNumber", line.LineNumber,
					"error", compensateErr)
			}

			result.Failed++
			result.FailedLines = append(result.FailedLines, FailedLine{
				LineNumber: line.LineNumber,
				Reference:  line.Reference,
				Error:      err.Error(),
			})

			// Continue processing remaining lines - don't fail the batch
			continue
		}

		result.Successful++
	}

	logger.Info("Bulk payment workflow completed",
		"batchID", input.BatchID,
		"successful", result.Successful,
		"failed", result.Failed)

	return result, nil
}

func processPaymentLine(ctx workflow.Context, batchID string, line SinglePaymentLine) error {
	// Update line status to PROCESSING
	err := workflow.ExecuteActivity(ctx, UpdateLineStatus, UpdateLineStatusInput{
		BatchID:    batchID,
		LineNumber: line.LineNumber,
		Status:     "PROCESSING",
	}).Get(ctx, nil)
	if err != nil {
		return fmt.Errorf("failed to update line status: %w", err)
	}

	// Execute the actual payment
	var paymentResult PaymentLineResult
	err = workflow.ExecuteActivity(ctx, ExecutePaymentLine, line.PaymentData).Get(ctx, &paymentResult)
	if err != nil {
		return err
	}

	// Update line status to COMPLETED
	return workflow.ExecuteActivity(ctx, UpdateLineStatus, UpdateLineStatusInput{
		BatchID:       batchID,
		LineNumber:    line.LineNumber,
		Status:        "COMPLETED",
		TransactionID: paymentResult.TransactionID,
	}).Get(ctx, nil)
}

// compensateFailedLine reverts the line status so it can be retried
func compensateFailedLine(ctx workflow.Context, batchID string, line SinglePaymentLine) error {
	return workflow.ExecuteActivity(ctx, RevertLineStatus, RevertLineStatusInput{
		BatchID:    batchID,
		LineNumber: line.LineNumber,
		Status:     "FAILED",
	}).Get(ctx, nil)
}

func SEPAPayment(ctx workflow.Context, input SEPAPaymentInput) (*SEPAPaymentOutput, error) {
	// ... skipped steps for brevity ...

	// We added activity tracking in a later release
	// Use versioning to handle in-flight workflows
	activityTrackingVersion := workflow.GetVersion(ctx,
		"activity-tracking-v1",  // Unique identifier for this change
		workflow.DefaultVersion, // Version 0: old code path
		1,                       // Version 1: new code path
	)

	if activityTrackingVersion >= 1 {
		// New path: Send status updates for real-time UI
		_ = workflow.ExecuteActivity(ctx, PublishStatusUpdate, StatusUpdate{
			PaymentID: input.PaymentID,
			Status:    "PROCESSING",
			Step:      "FRAUD_CHECK",
		}).Get(ctx, nil)
	}

	// ... continue with fraud check ...

	// Another versioned change: we switched from signal-based approvals
	// to direct API calls
	approvalVersion := workflow.GetVersion(ctx,
		"approval-api-v2",
		workflow.DefaultVersion,
		2,
	)

	if approvalVersion >= 2 {
		// V2: Direct approval check
		err := workflow.ExecuteActivity(ctx, CheckApprovalDirect, input).Get(ctx, nil)
		if err != nil {
			return nil, err
		}
	} else if approvalVersion == 1 {
		// V1: Signal-based approval (deprecated)
		err := waitForApprovalSignal(ctx, input.PaymentID)
		if err != nil {
			return nil, err
		}
	}

	// ... rest of workflow ...
}

package activities

import (
	"context"
	"errors"
	"fmt"

	"go.temporal.io/sdk/temporal"
)

// Custom error types for business logic failures
var (
	ErrInsufficientFunds  = errors.New("insufficient funds")
	ErrAccountFrozen      = errors.New("account frozen")
	ErrInvalidBeneficiary = errors.New("invalid beneficiary")
	ErrDuplicatePayment   = errors.New("duplicate payment detected")
	ErrFraudRejected      = errors.New("rejected by fraud system")
	ErrUserCancelled      = errors.New("cancelled by user")
)

// ValidatePayment checks if a payment can proceed
func ValidatePayment(ctx context.Context, input SEPAPaymentInput) (ValidationResult, error) {
	// Check account balance
	balance, err := accountsClient.GetBalance(ctx, input.SourceAccountID)
	if err != nil {
		// Network error - Temporal should retry
		return ValidationResult{}, fmt.Errorf("failed to get balance: %w", err)
	}

	if balance < input.Amount {
		// Business error - don't retry, it won't help
		return ValidationResult{}, temporal.NewNonRetryableApplicationError(
			fmt.Sprintf("Insufficient funds: available %d, required %d", balance, input.Amount),
			"INSUFFICIENT_FUNDS",
			ErrInsufficientFunds,
		)
	}

	// Check account status
	account, err := accountsClient.GetAccount(ctx, input.SourceAccountID)
	if err != nil {
		return ValidationResult{}, fmt.Errorf("failed to get account: %w", err)
	}

	if account.Status == "FROZEN" {
		return ValidationResult{}, temporal.NewNonRetryableApplicationError(
			"Account is frozen",
			"ACCOUNT_FROZEN",
			ErrAccountFrozen,
		)
	}

	// Validate IBAN format
	if !isValidIBAN(input.DestinationIBAN) {
		return ValidationResult{}, temporal.NewNonRetryableApplicationError(
			fmt.Sprintf("Invalid IBAN format: %s", input.DestinationIBAN),
			"INVALID_IBAN",
			ErrInvalidBeneficiary,
		)
	}

	return ValidationResult{Valid: true}, nil
}

// CheckFraud evaluates the payment for fraud risk
func CheckFraud(ctx context.Context, input SEPAPaymentInput) (FraudCheckResult, error) {
	result, err := fraudService.Evaluate(ctx, FraudRequest{
		CustomerID: input.CustomerID,
		Amount:     input.Amount,
		Recipient:  input.DestinationIBAN,
	})
	if err != nil {
		// Fraud service down - this is configured with MaxAttempts: 1
		// so we'll fail rather than proceed without fraud check
		return FraudCheckResult{}, fmt.Errorf("fraud service unavailable: %w", err)
	}

	if result.Decision == "REJECT" {
		// Fraud rejection is a result, not an error
		return FraudCheckResult{
			Rejected: true,
			Reason:   result.Reason,
		}, nil
	}

	return FraudCheckResult{
		Rejected: false,
		Score:    result.RiskScore,
	}, nil
}

package config

import (
	"time"

	"go.temporal.io/sdk/temporal"
	"go.temporal.io/sdk/worker"
)

const (
	PaymentTaskQueue = "payments-task-queue"

	// SWIFT payments can take days to settle
	WorkflowRunTimeout  = 7 * 24 * time.Hour
	WorkflowTaskTimeout = 10 * time.Minute

	DefaultActivityTimeout = 10 * time.Minute
	FraudCheckTimeout      = 30 * time.Second
	LegacyPublishTimeout   = 5 * time.Minute
)

// WorkerOptions returns production worker configuration
func WorkerOptions() worker.Options {
	return worker.Options{
		MaxConcurrentWorkflowTaskExecutionSize: 50,
		MaxConcurrentActivityExecutionSize:     100,
		MaxConcurrentWorkflowTaskPollers:       4,
		MaxConcurrentActivityTaskPollers:       8,
		StickyScheduleToStartTimeout:           5 * time.Second,
	}
}

// DefaultRetryPolicy for most activities
func DefaultRetryPolicy() *temporal.RetryPolicy {
	return &temporal.RetryPolicy{
		InitialInterval:    time.Second,
		BackoffCoefficient: 2.0,
		MaximumInterval:    time.Minute,
		MaximumAttempts:    5,
	}
}

// NoRetryPolicy for activities that shouldn't retry
func NoRetryPolicy() *temporal.RetryPolicy {
	return &temporal.RetryPolicy{
		MaximumAttempts: 1,
	}
}

package main

import (
	"log"
	"os"
	"os/signal"
	"syscall"

	"go.temporal.io/sdk/client"
	"go.temporal.io/sdk/worker"
)

func main() {
	c, err := client.Dial(client.Options{
		HostPort:  os.Getenv("TEMPORAL_HOST"),
		Namespace: os.Getenv("TEMPORAL_NAMESPACE"),
	})
	if err != nil {
		log.Fatalf("Failed to create Temporal client: %v", err)
	}
	defer c.Close()

	w := worker.New(c, config.PaymentTaskQueue, config.WorkerOptions())

	// Register workflows
	w.RegisterWorkflow(workflow.SEPAPayment)
	w.RegisterWorkflow(workflow.SWIFTPayment)
	w.RegisterWorkflow(workflow.DomesticPayment)
	w.RegisterWorkflow(workflow.BulkPaymentWorkflow)
	w.RegisterWorkflow(workflow.StandingOrderWorkflow)

	// Register activities
	registerActivities(w)

	go func() {
		if err := w.Run(worker.InterruptCh()); err != nil {
			log.Fatalf("Worker failed: %v", err)
		}
	}()

	quit := make(chan os.Signal, 1)
	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
	<-quit
	log.Println("Shutting down worker...")
	w.Stop()
}

func registerActivities(w worker.Worker) {
	accountAct := activities.NewAccountActivities(accountsClient)
	w.RegisterActivity(accountAct.GetAccount)
	w.RegisterActivity(accountAct.GetBalance)
	w.RegisterActivity(accountAct.DebitAccount)

	fraudAct := activities.NewFraudActivities(fraudClient)
	w.RegisterActivity(fraudAct.CheckFraud)

	mqAct := activities.NewMQActivities(mqPublisher)
	w.RegisterActivity(mqAct.PublishToLegacyBanking)

	validationAct := activities.NewValidationActivities(validationService)
	w.RegisterActivity(validationAct.ValidatePayment)

	statusAct := activities.NewStatusActivities(statusService)
	w.RegisterActivity(statusAct.UpdatePaymentStatus)
	w.RegisterActivity(statusAct.PublishStatusUpdate)
}

// DON'T: Arbitrary timeout that doesn't match business reality
WorkflowRunTimeout: 1 * time.Hour

// DO: Match the business process
WorkflowRunTimeout: 7 * 24 * time.Hour // International payments can take days

err := temporalClient.SignalWorkflow(ctx, workflowID, "", signalName, data)
if err != nil {
	if isWorkflowNotFoundError(err) {
		// Workflow already completed - log and move on
		logger.Info("Workflow already completed, signal dropped",
			"workflowID", workflowID)
		return nil
	}
	return err
}

v := workflow.GetVersion(ctx, "change-identifier", workflow.DefaultVersion, 1)
if v >= 1 {
	// New behavior
} else {
	// Old behavior (for in-flight workflows)
}

// DON'T: Vague error
return temporal.NewNonRetryableApplicationError("failed", "ERROR", nil)

// DO: Clear, actionable error
return temporal.NewNonRetryableApplicationError(
	fmt.Sprintf("Payment rejected: Account %s has insufficient funds. "+
		"Available: £%.2f, Required: £%.2f",
		accountID, float64(balance)/100, float64(amount)/100),
	"INSUFFICIENT_FUNDS",
	ErrInsufficientFunds,
)