Top 20 AWS Step Functions Interview Questions

What is AWS Step Functions?
What are Step Functions workflow types?
What is Amazon States Language (ASL)?
What are the different state types?
How do you handle errors in Step Functions?
What are Task states?
How do you implement parallel execution?
What are Map states?
How do you manage data flow between states?
What are intrinsic functions?
How do you implement human approval workflows?
What are service integrations?
How do you handle long-running tasks?
What are execution events and history?
How do you implement versioning?
What are Step Functions best practices?
How do you test Step Functions?
What is Step Functions Express vs Standard?
How do you monitor Step Functions?
What are common Step Functions patterns?

AWS Interview Questions - All Topics

AWS Data Engineer AWS Lambda AWS Redshift AWS S3 & Lake Formation AWS EMR & Glue AWS Step Functions AWS IAM & Cognito AWS SageMaker AWS CI/CD (CodePipeline) AWS Kinesis AWS Data Real-time Scenarios

1. What is AWS Step Functions?

AWS Step Functions is a serverless workflow orchestration service for coordinating distributed applications and microservices.

Step Functions Features:
âââ Visual workflow designer
âââ Built-in error handling
âââ State management
âââ Service integrations (200+)
âââ Parallel and sequential execution
âââ Audit and execution history

Use Cases:
âââ ETL/Data pipelines
âââ Microservice orchestration
âââ Human approval workflows
âââ IT automation
âââ Machine learning pipelines
âââ Order processing

# Simple workflow example
{
  "Comment": "A simple sequential workflow",
  "StartAt": "FirstState",
  "States": {
    "FirstState": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:MyFunction",
      "Next": "SecondState"
    },
    "SecondState": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:AnotherFunction",
      "End": true
    }
  }
}

2. What are Step Functions workflow types?

Feature	Standard	Express
Duration	Up to 1 year	Up to 5 minutes
Execution rate	2,000/sec	100,000/sec
Pricing	Per state transition	Per execution + duration
Execution history	Full history	CloudWatch Logs
Use case	Long-running	High-volume, short

# Create Standard workflow
import boto3
sfn = boto3.client('stepfunctions')

sfn.create_state_machine(
    name='StandardWorkflow',
    definition=json.dumps(workflow_definition),
    roleArn='arn:aws:iam::123456789012:role/StepFunctionsRole',
    type='STANDARD'
)

# Create Express workflow
sfn.create_state_machine(
    name='ExpressWorkflow',
    definition=json.dumps(workflow_definition),
    roleArn='arn:aws:iam::123456789012:role/StepFunctionsRole',
    type='EXPRESS',
    loggingConfiguration={
        'level': 'ALL',
        'includeExecutionData': True,
        'destinations': [{
            'cloudWatchLogsLogGroup': {
                'logGroupArn': 'arn:aws:logs:us-east-1:123456789012:log-group:express-logs'
            }
        }]
    }
)

Express Workflow Modes:
âââ Synchronous: Wait for result (API Gateway)
âââ Asynchronous: Fire and forget

3. What is Amazon States Language (ASL)?

ASL is a JSON-based language for defining Step Functions state machines.

ASL Structure:
{
  "Comment": "Description of workflow",
  "StartAt": "FirstStateName",
  "TimeoutSeconds": 3600,
  "Version": "1.0",
  "States": {
    "FirstStateName": {
      "Type": "Task|Pass|Choice|Wait|Succeed|Fail|Parallel|Map",
      "Comment": "State description",
      "InputPath": "$.input",
      "OutputPath": "$.output",
      "ResultPath": "$.result",
      "Parameters": {},
      "ResultSelector": {},
      "Next": "NextStateName",
      "End": true
    }
  }
}

Key Fields:
âââ StartAt: First state to execute
âââ States: Map of state definitions
âââ Type: State type (Task, Choice, etc.)
âââ Next: Next state to transition to
âââ End: Marks terminal state
âââ InputPath: Filter input data
âââ OutputPath: Filter output data
âââ ResultPath: Where to place result
âââ Parameters: State input parameters

# Complete example
{
  "Comment": "Order processing workflow",
  "StartAt": "ValidateOrder",
  "States": {
    "ValidateOrder": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:...:function:validate",
      "Next": "CheckInventory",
      "Catch": [{
        "ErrorEquals": ["ValidationError"],
        "Next": "OrderFailed"
      }]
    },
    "CheckInventory": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:...:function:inventory",
      "Next": "ProcessPayment"
    },
    "ProcessPayment": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:...:function:payment",
      "Next": "OrderComplete"
    },
    "OrderComplete": {
      "Type": "Succeed"
    },
    "OrderFailed": {
      "Type": "Fail",
      "Error": "OrderProcessingFailed",
      "Cause": "Order validation failed"
    }
  }
}

4. What are the different state types?

State Types:

1. Task - Execute work
{
  "Type": "Task",
  "Resource": "arn:aws:lambda:...:function:MyFunction",
  "Next": "NextState"
}

2. Pass - Pass input to output (no-op)
{
  "Type": "Pass",
  "Result": {"status": "processed"},
  "ResultPath": "$.metadata",
  "Next": "NextState"
}

3. Choice - Conditional branching
{
  "Type": "Choice",
  "Choices": [
    {
      "Variable": "$.status",
      "StringEquals": "approved",
      "Next": "ProcessApproved"
    },
    {
      "Variable": "$.amount",
      "NumericGreaterThan": 1000,
      "Next": "ManualReview"
    }
  ],
  "Default": "ProcessDefault"
}

4. Wait - Delay execution
{
  "Type": "Wait",
  "Seconds": 60,
  "Next": "NextState"
}
// Or wait until timestamp
{
  "Type": "Wait",
  "TimestampPath": "$.scheduledTime",
  "Next": "NextState"
}

5. Parallel - Execute branches concurrently
{
  "Type": "Parallel",
  "Branches": [...],
  "Next": "NextState"
}

6. Map - Iterate over array
{
  "Type": "Map",
  "ItemsPath": "$.items",
  "Iterator": {...},
  "Next": "NextState"
}

7. Succeed - Terminal success
{
  "Type": "Succeed"
}

8. Fail - Terminal failure
{
  "Type": "Fail",
  "Error": "CustomError",
  "Cause": "Error description"
}

5. How do you handle errors in Step Functions?

Error Handling Mechanisms:

1. Retry - Automatic retry with backoff
{
  "Type": "Task",
  "Resource": "arn:aws:lambda:...",
  "Retry": [
    {
      "ErrorEquals": ["States.Timeout", "Lambda.ServiceException"],
      "IntervalSeconds": 3,
      "MaxAttempts": 3,
      "BackoffRate": 2.0,
      "MaxDelaySeconds": 60,
      "JitterStrategy": "FULL"
    },
    {
      "ErrorEquals": ["States.ALL"],
      "IntervalSeconds": 1,
      "MaxAttempts": 2
    }
  ],
  "Next": "NextState"
}

2. Catch - Handle errors gracefully
{
  "Type": "Task",
  "Resource": "arn:aws:lambda:...",
  "Catch": [
    {
      "ErrorEquals": ["ValidationError"],
      "ResultPath": "$.error",
      "Next": "HandleValidationError"
    },
    {
      "ErrorEquals": ["States.TaskFailed"],
      "ResultPath": "$.error",
      "Next": "HandleTaskFailure"
    },
    {
      "ErrorEquals": ["States.ALL"],
      "ResultPath": "$.error",
      "Next": "CatchAllHandler"
    }
  ],
  "Next": "SuccessState"
}

Predefined Error Types:
âââ States.ALL: Matches any error
âââ States.Timeout: Task timeout
âââ States.TaskFailed: Task failure
âââ States.Permissions: Permission error
âââ States.ResultPathMatchFailure: ResultPath issue
âââ States.ParameterPathFailure: Parameter issue
âââ States.BranchFailed: Parallel branch failure
âââ States.NoChoiceMatched: No Choice match
âââ States.HeartbeatTimeout: Activity heartbeat timeout

6. What are Task states?

Task states execute work using integrated services or activities.

Task Resource Types:

1. Lambda Function
{
  "Type": "Task",
  "Resource": "arn:aws:lambda:us-east-1:123456789012:function:MyFunction",
  "Parameters": {
    "input.$": "$",
    "customParam": "value"
  },
  "TimeoutSeconds": 300,
  "Next": "NextState"
}

2. AWS SDK Integration (direct service call)
{
  "Type": "Task",
  "Resource": "arn:aws:states:::aws-sdk:dynamodb:putItem",
  "Parameters": {
    "TableName": "MyTable",
    "Item": {
      "pk": {"S.$": "$.id"},
      "data": {"S.$": "$.data"}
    }
  },
  "Next": "NextState"
}

3. Optimized Service Integration
{
  "Type": "Task",
  "Resource": "arn:aws:states:::sqs:sendMessage",
  "Parameters": {
    "QueueUrl": "https://sqs.../queue",
    "MessageBody.$": "$.message"
  },
  "Next": "NextState"
}

4. Activity (external worker)
{
  "Type": "Task",
  "Resource": "arn:aws:states:us-east-1:123456789012:activity:MyActivity",
  "TimeoutSeconds": 600,
  "HeartbeatSeconds": 60,
  "Next": "NextState"
}

Integration Patterns:
âââ Request-Response: Invoke and get result
âââ Run a Job (.sync): Wait for job completion
âââ Wait for Callback (.waitForTaskToken): External callback

7. How do you implement parallel execution?

Parallel State:
{
  "Type": "Parallel",
  "Branches": [
    {
      "StartAt": "Branch1Task1",
      "States": {
        "Branch1Task1": {
          "Type": "Task",
          "Resource": "arn:aws:lambda:...:function:Branch1Func",
          "Next": "Branch1Task2"
        },
        "Branch1Task2": {
          "Type": "Task",
          "Resource": "arn:aws:lambda:...:function:Branch1Func2",
          "End": true
        }
      }
    },
    {
      "StartAt": "Branch2Task1",
      "States": {
        "Branch2Task1": {
          "Type": "Task",
          "Resource": "arn:aws:lambda:...:function:Branch2Func",
          "End": true
        }
      }
    },
    {
      "StartAt": "Branch3Task1",
      "States": {
        "Branch3Task1": {
          "Type": "Pass",
          "Result": {"branch": 3},
          "End": true
        }
      }
    }
  ],
  "ResultPath": "$.parallelResults",
  "Catch": [{
    "ErrorEquals": ["States.ALL"],
    "ResultPath": "$.error",
    "Next": "HandleParallelError"
  }],
  "Next": "ProcessParallelResults"
}

# Output is array of branch results
# $.parallelResults = [branch1Result, branch2Result, branch3Result]

Error Handling:
âââ If any branch fails, entire Parallel fails
âââ Use Catch for graceful handling
âââ Each branch can have its own Retry/Catch

8. What are Map states?

Map states process arrays of items either inline or distributed.

# Inline Map (up to 40 concurrent)
{
  "Type": "Map",
  "ItemsPath": "$.orders",
  "MaxConcurrency": 10,
  "ItemSelector": {
    "orderId.$": "$$.Map.Item.Value.id",
    "index.$": "$$.Map.Item.Index",
    "executionId.$": "$$.Execution.Id"
  },
  "ItemProcessor": {
    "ProcessorConfig": {
      "Mode": "INLINE"
    },
    "StartAt": "ProcessOrder",
    "States": {
      "ProcessOrder": {
        "Type": "Task",
        "Resource": "arn:aws:lambda:...:function:ProcessOrder",
        "End": true
      }
    }
  },
  "ResultPath": "$.processedOrders",
  "Next": "AggregateResults"
}

# Distributed Map (millions of items)
{
  "Type": "Map",
  "ItemReader": {
    "Resource": "arn:aws:states:::s3:getObject",
    "ReaderConfig": {
      "InputType": "JSON"
    },
    "Parameters": {
      "Bucket": "my-bucket",
      "Key": "items.json"
    }
  },
  "ItemProcessor": {
    "ProcessorConfig": {
      "Mode": "DISTRIBUTED",
      "ExecutionType": "STANDARD"
    },
    "StartAt": "ProcessItem",
    "States": {
      "ProcessItem": {
        "Type": "Task",
        "Resource": "arn:aws:lambda:...",
        "End": true
      }
    }
  },
  "MaxConcurrency": 1000,
  "ToleratedFailurePercentage": 5,
  "ResultWriter": {
    "Resource": "arn:aws:states:::s3:putObject",
    "Parameters": {
      "Bucket": "results-bucket",
      "Prefix": "results/"
    }
  },
  "Next": "Complete"
}

9. How do you manage data flow between states?

Data Flow Processing Order:
1. InputPath - Filter input
2. Parameters - Construct task input
3. [Task executes]
4. ResultSelector - Filter result
5. ResultPath - Place result in state
6. OutputPath - Filter final output

# Example with all data flow fields
{
  "Type": "Task",
  "Resource": "arn:aws:lambda:...",
  "InputPath": "$.order",  // Only pass order object
  "Parameters": {
    "orderId.$": "$.id",
    "items.$": "$.items",
    "timestamp.$": "$$.State.EnteredTime"
  },
  "ResultSelector": {
    "status.$": "$.Payload.status",
    "processedAt.$": "$.Payload.timestamp"
  },
  "ResultPath": "$.orderResult",  // Add result here
  "OutputPath": "$",  // Pass everything
  "Next": "NextState"
}

# Input: {"order": {"id": "123", "items": [...], "customer": "John"}}
# After InputPath: {"id": "123", "items": [...], "customer": "John"}
# Task receives: {"orderId": "123", "items": [...], "timestamp": "..."}
# Task returns: {"Payload": {"status": "processed", "timestamp": "...", "extra": "data"}}
# After ResultSelector: {"status": "processed", "processedAt": "..."}
# After ResultPath: original input + {"orderResult": {"status": "processed", ...}}

Context Object ($$):
âââ $$.Execution.Id
âââ $$.Execution.StartTime
âââ $$.State.Name
âââ $$.State.EnteredTime
âââ $$.StateMachine.Id
âââ $$.Map.Item.Index
âââ $$.Map.Item.Value

10. What are intrinsic functions?

Intrinsic functions perform data transformations within ASL.

# String Functions
{
  "Parameters": {
    "formatted.$": "States.Format('Order {} processed at {}', $.orderId, $$.State.EnteredTime)",
    "joined.$": "States.StringToJson($.jsonString)",
    "split.$": "States.StringSplit('a,b,c', ',')",
    "uuid.$": "States.UUID()"
  }
}

# Array Functions
{
  "Parameters": {
    "first.$": "States.ArrayGetItem($.items, 0)",
    "length.$": "States.ArrayLength($.items)",
    "contains.$": "States.ArrayContains($.items, 'target')",
    "unique.$": "States.ArrayUnique($.items)",
    "partitioned.$": "States.ArrayPartition($.items, 10)",
    "range.$": "States.ArrayRange(1, 10, 2)"  // [1,3,5,7,9]
  }
}

# Math Functions
{
  "Parameters": {
    "sum.$": "States.MathAdd($.a, $.b)",
    "random.$": "States.MathRandom(1, 100)"
  }
}

# JSON Functions
{
  "Parameters": {
    "merged.$": "States.JsonMerge($.obj1, $.obj2, false)",
    "toString.$": "States.JsonToString($.object)"
  }
}

# Hash Functions
{
  "Parameters": {
    "hash.$": "States.Hash($.data, 'SHA-256')",
    "base64.$": "States.Base64Encode($.text)"
  }
}

11. How do you implement human approval workflows?

# Wait for Callback Pattern
{
  "Comment": "Human approval workflow",
  "StartAt": "SubmitForApproval",
  "States": {
    "SubmitForApproval": {
      "Type": "Task",
      "Resource": "arn:aws:states:::lambda:invoke.waitForTaskToken",
      "Parameters": {
        "FunctionName": "SendApprovalRequest",
        "Payload": {
          "taskToken.$": "$$.Task.Token",
          "requestId.$": "$.requestId",
          "details.$": "$.details",
          "approvers.$": "$.approvers"
        }
      },
      "TimeoutSeconds": 86400,  // 24 hours
      "Catch": [{
        "ErrorEquals": ["States.Timeout"],
        "ResultPath": "$.error",
        "Next": "ApprovalTimeout"
      }],
      "Next": "CheckApproval"
    },
    "CheckApproval": {
      "Type": "Choice",
      "Choices": [{
        "Variable": "$.approved",
        "BooleanEquals": true,
        "Next": "ProcessApproved"
      }],
      "Default": "ProcessRejected"
    },
    "ProcessApproved": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:...",
      "End": true
    },
    "ProcessRejected": {
      "Type": "Fail",
      "Error": "RequestRejected"
    },
    "ApprovalTimeout": {
      "Type": "Fail",
      "Error": "ApprovalTimeout"
    }
  }
}

# Lambda sends email with approval link
# Approval API calls SendTaskSuccess/SendTaskFailure

# Resume execution
sfn.send_task_success(
    taskToken=token,
    output=json.dumps({"approved": True, "approver": "user@example.com"})
)

# Or reject
sfn.send_task_failure(
    taskToken=token,
    error="Rejected",
    cause="Manager rejected the request"
)

12. What are service integrations?

Step Functions integrates with 200+ AWS services directly.

Integration Patterns:

1. Request Response (default)
{
  "Resource": "arn:aws:states:::lambda:invoke",
  "Parameters": {...}
}

2. Run a Job (.sync) - Wait for completion
{
  "Resource": "arn:aws:states:::glue:startJobRun.sync",
  "Parameters": {
    "JobName": "my-etl-job"
  }
}

3. Wait for Callback (.waitForTaskToken)
{
  "Resource": "arn:aws:states:::sqs:sendMessage.waitForTaskToken",
  "Parameters": {
    "QueueUrl": "...",
    "MessageBody": {
      "token.$": "$$.Task.Token"
    }
  }
}

# Common Service Integrations

# DynamoDB
{
  "Resource": "arn:aws:states:::dynamodb:putItem",
  "Parameters": {
    "TableName": "Orders",
    "Item": {"pk": {"S.$": "$.id"}}
  }
}

# SQS
{
  "Resource": "arn:aws:states:::sqs:sendMessage",
  "Parameters": {
    "QueueUrl": "https://sqs...",
    "MessageBody.$": "$.message"
  }
}

# SNS
{
  "Resource": "arn:aws:states:::sns:publish",
  "Parameters": {
    "TopicArn": "arn:aws:sns:...",
    "Message.$": "$.notification"
  }
}

# ECS/Fargate
{
  "Resource": "arn:aws:states:::ecs:runTask.sync",
  "Parameters": {
    "LaunchType": "FARGATE",
    "Cluster": "arn:aws:ecs:...",
    "TaskDefinition": "my-task"
  }
}

# Glue
{
  "Resource": "arn:aws:states:::glue:startJobRun.sync",
  "Parameters": {
    "JobName": "etl-job",
    "Arguments": {"--input.$": "$.inputPath"}
  }
}

# Bedrock
{
  "Resource": "arn:aws:states:::bedrock:invokeModel",
  "Parameters": {
    "ModelId": "anthropic.claude-3-sonnet-20240229-v1:0",
    "Body": {"prompt.$": "$.userPrompt"}
  }
}

13. How do you handle long-running tasks?

Long-Running Task Strategies:

1. Activity with Heartbeat
{
  "Type": "Task",
  "Resource": "arn:aws:states:...:activity:LongRunningActivity",
  "HeartbeatSeconds": 60,
  "TimeoutSeconds": 3600,
  "Next": "Complete"
}

# Worker code
while True:
    task = sfn.get_activity_task(activityArn=activity_arn)
    if task.get('taskToken'):
        try:
            # Process with heartbeats
            for chunk in process_data(task['input']):
                sfn.send_task_heartbeat(taskToken=task['taskToken'])
            
            sfn.send_task_success(
                taskToken=task['taskToken'],
                output=json.dumps(result)
            )
        except Exception as e:
            sfn.send_task_failure(
                taskToken=task['taskToken'],
                error='ProcessingError',
                cause=str(e)
            )

2. Run Job Sync (managed polling)
# Step Functions handles polling automatically
{
  "Resource": "arn:aws:states:::batch:submitJob.sync",
  "Parameters": {
    "JobDefinition": "my-job-def",
    "JobName": "my-job",
    "JobQueue": "my-queue"
  }
}

3. Callback Pattern
{
  "Resource": "arn:aws:states:::ecs:runTask.waitForTaskToken",
  "Parameters": {
    "Cluster": "...",
    "TaskDefinition": "...",
    "Overrides": {
      "ContainerOverrides": [{
        "Name": "container",
        "Environment": [{
          "Name": "TASK_TOKEN",
          "Value.$": "$$.Task.Token"
        }]
      }]
    }
  }
}

14. What are execution events and history?

# Get execution history
history = sfn.get_execution_history(
    executionArn='arn:aws:states:...:execution:MyStateMachine:exec-id',
    maxResults=100
)

for event in history['events']:
    print(f"{event['timestamp']} - {event['type']}")
    # Event types: TaskStateEntered, TaskStateExited, LambdaFunctionScheduled,
    # LambdaFunctionSucceeded, ExecutionSucceeded, etc.

Event Types:
âââ ExecutionStarted
âââ ExecutionSucceeded/Failed/Aborted/TimedOut
âââ TaskStateEntered/Exited
âââ TaskScheduled/Started/Succeeded/Failed
âââ ChoiceStateEntered/Exited
âââ ParallelStateEntered/Exited
âââ MapStateEntered/Exited
âââ WaitStateEntered/Exited
âââ PassStateEntered/Exited

# List executions
executions = sfn.list_executions(
    stateMachineArn='arn:aws:states:...',
    statusFilter='RUNNING',  # RUNNING, SUCCEEDED, FAILED, TIMED_OUT, ABORTED
    maxResults=20
)

# Describe execution
execution = sfn.describe_execution(
    executionArn='arn:aws:states:...:execution:...'
)
print(f"Status: {execution['status']}")
print(f"Input: {execution['input']}")
print(f"Output: {execution.get('output')}")

# Standard: Full history retained (90 days default)
# Express: Send to CloudWatch Logs

15. How do you implement versioning?

Versioning and Aliases:

# Create version (publish current revision)
version = sfn.publish_state_machine_version(
    stateMachineArn='arn:aws:states:...',
    description='Version 1.0 - Initial release'
)
# Returns: arn:aws:states:...:stateMachine:MyMachine:1

# Create alias pointing to version
sfn.create_state_machine_alias(
    name='prod',
    routingConfiguration=[
        {
            'stateMachineVersionArn': version['stateMachineVersionArn'],
            'weight': 100
        }
    ]
)
# Returns: arn:aws:states:...:stateMachine:MyMachine:prod

# Canary deployment (weighted routing)
sfn.update_state_machine_alias(
    stateMachineAliasArn='arn:aws:states:...:stateMachine:MyMachine:prod',
    routingConfiguration=[
        {
            'stateMachineVersionArn': 'arn:aws:states:...:stateMachine:MyMachine:1',
            'weight': 90
        },
        {
            'stateMachineVersionArn': 'arn:aws:states:...:stateMachine:MyMachine:2',
            'weight': 10
        }
    ]
)

# Start execution using alias
sfn.start_execution(
    stateMachineArn='arn:aws:states:...:stateMachine:MyMachine:prod',
    input=json.dumps({"data": "value"})
)

Benefits:
âââ Immutable versions
âââ Blue/green deployments
âââ Gradual rollouts
âââ Easy rollbacks

16. What are Step Functions best practices?

1. Design for Idempotency
# Tasks should handle retries safely
# Use unique identifiers for deduplication
{
  "Parameters": {
    "requestId.$": "States.UUID()",
    "idempotencyKey.$": "$.orderId"
  }
}

2. Minimize Payload Size
# Store large data in S3
# Pass references, not data
{
  "Type": "Task",
  "Resource": "arn:aws:states:::s3:putObject",
  "Parameters": {
    "Bucket": "my-bucket",
    "Key.$": "States.Format('data/{}.json', $.id)",
    "Body.$": "$.largePayload"
  },
  "ResultPath": "$.s3Location",
  "Next": "ProcessReference"
}

3. Use Proper Error Handling
{
  "Retry": [{
    "ErrorEquals": ["Lambda.ServiceException", "Lambda.TooManyRequestsException"],
    "IntervalSeconds": 2,
    "MaxAttempts": 6,
    "BackoffRate": 2,
    "JitterStrategy": "FULL"
  }],
  "Catch": [{
    "ErrorEquals": ["States.ALL"],
    "ResultPath": "$.error",
    "Next": "ErrorHandler"
  }]
}

4. Set Appropriate Timeouts
{
  "TimeoutSeconds": 300,
  "HeartbeatSeconds": 60
}

5. Use Service Integrations
# Prefer native integrations over Lambda wrappers
# More efficient and cost-effective

6. Monitor with CloudWatch
# Enable X-Ray tracing
# Set up alarms on execution failures

17. How do you test Step Functions?

Testing Approaches:

1. Step Functions Local (Docker)
# Download and run locally
docker run -p 8083:8083 \
    amazon/aws-stepfunctions-local

# Create state machine
aws stepfunctions create-state-machine \
    --endpoint http://localhost:8083 \
    --name LocalTest \
    --definition file://definition.json \
    --role-arn arn:aws:iam::012345678901:role/DummyRole

# Start execution
aws stepfunctions start-execution \
    --endpoint http://localhost:8083 \
    --state-machine-arn arn:aws:states:us-east-1:123456789012:stateMachine:LocalTest \
    --input '{"key": "value"}'

2. TestState API (test individual states)
import boto3
sfn = boto3.client('stepfunctions')

result = sfn.test_state(
    definition=json.dumps({
        "Type": "Task",
        "Resource": "arn:aws:states:::dynamodb:getItem",
        "Parameters": {
            "TableName": "MyTable",
            "Key": {"pk": {"S.$": "$.id"}}
        }
    }),
    roleArn='arn:aws:iam::123456789012:role/TestRole',
    input=json.dumps({"id": "123"})
)
print(result['output'])

3. Mocking with Step Functions Local
# Configure mock responses
{
  "StateMachines": {
    "MyStateMachine": {
      "TestCases": {
        "HappyPath": {
          "LambdaFunction": {
            "Return": {"statusCode": 200}
          }
        }
      }
    }
  }
}

4. Integration Tests
# Deploy to test environment
# Use test aliases
# Validate execution history

18. What is Step Functions Express vs Standard?

Comparison:

Standard Workflows:
âââ Duration: Up to 1 year
âââ Execution rate: 2,000 starts/second
âââ State transitions: 40,000 per account
âââ Pricing: $0.025 per 1,000 state transitions
âââ Execution history: Full (90 days)
âââ Use cases:
â   âââ Long-running processes
â   âââ Human approval workflows
â   âââ ETL pipelines
â   âââ Order processing

Express Workflows:
âââ Duration: Up to 5 minutes
âââ Execution rate: 100,000 starts/second
âââ Pricing: Based on executions + duration
âââ Execution history: CloudWatch Logs only
âââ Modes: Synchronous, Asynchronous
âââ Use cases:
â   âââ IoT data processing
â   âââ Streaming data
â   âââ API orchestration
â   âââ High-volume transactions

# Express Synchronous (API Gateway)
{
  "Type": "AWS::Serverless::StateMachine",
  "Properties": {
    "Type": "EXPRESS",
    "Events": {
      "Api": {
        "Type": "Api",
        "Properties": {
          "Method": "POST",
          "Path": "/process"
        }
      }
    }
  }
}

# Cost Example (1M executions, 10 state transitions each)
# Standard: 1M * 10 * $0.000025 = $250
# Express: Depends on duration, often cheaper for high-volume

19. How do you monitor Step Functions?

Monitoring Options:

1. CloudWatch Metrics
âââ ExecutionsStarted
âââ ExecutionsSucceeded
âââ ExecutionsFailed
âââ ExecutionsAborted
âââ ExecutionsTimedOut
âââ ExecutionTime
âââ ExecutionThrottled

# CloudWatch Alarm
cloudwatch.put_metric_alarm(
    AlarmName='StepFunctions-Failures',
    MetricName='ExecutionsFailed',
    Namespace='AWS/States',
    Dimensions=[
        {'Name': 'StateMachineArn', 'Value': state_machine_arn}
    ],
    Statistic='Sum',
    Period=300,
    EvaluationPeriods=1,
    Threshold=1,
    ComparisonOperator='GreaterThanOrEqualToThreshold',
    AlarmActions=['arn:aws:sns:...']
)

2. X-Ray Tracing
{
  "Type": "AWS::StepFunctions::StateMachine",
  "Properties": {
    "TracingConfiguration": {
      "Enabled": true
    }
  }
}

3. CloudWatch Logs (Express)
{
  "loggingConfiguration": {
    "level": "ALL",
    "includeExecutionData": true,
    "destinations": [{
      "cloudWatchLogsLogGroup": {
        "logGroupArn": "arn:aws:logs:..."
      }
    }]
  }
}

4. EventBridge Integration
# React to execution status changes
{
  "source": ["aws.states"],
  "detail-type": ["Step Functions Execution Status Change"],
  "detail": {
    "status": ["FAILED", "TIMED_OUT"]
  }
}

20. What are common Step Functions patterns?

1. Saga Pattern (Distributed Transactions)
{
  "States": {
    "ReserveInventory": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:...:reserve",
      "Catch": [{"ErrorEquals": ["States.ALL"], "Next": "CompensateInventory"}],
      "Next": "ProcessPayment"
    },
    "ProcessPayment": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:...:payment",
      "Catch": [{"ErrorEquals": ["States.ALL"], "Next": "CompensatePayment"}],
      "Next": "ShipOrder"
    },
    "CompensatePayment": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:...:refund",
      "Next": "CompensateInventory"
    },
    "CompensateInventory": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:...:release",
      "Next": "FailOrder"
    }
  }
}

2. Fan-Out/Fan-In
{
  "Type": "Map",
  "ItemsPath": "$.items",
  "MaxConcurrency": 10,
  "ItemProcessor": {...},
  "ResultPath": "$.results",
  "Next": "Aggregate"
}

3. Circuit Breaker
# Use Choice state to check failure counts
# Implement "open" state that fast-fails

4. Polling Pattern
{
  "CheckStatus": {
    "Type": "Task",
    "Resource": "arn:aws:lambda:...:checkStatus",
    "Next": "IsComplete"
  },
  "IsComplete": {
    "Type": "Choice",
    "Choices": [{
      "Variable": "$.status",
      "StringEquals": "COMPLETE",
      "Next": "Success"
    }],
    "Default": "Wait"
  },
  "Wait": {
    "Type": "Wait",
    "Seconds": 30,
    "Next": "CheckStatus"
  }
}

5. ETL Pipeline
StartAt â Crawl â Transform â Load â Notify