AWS Step Functions Use Cases
Tags: serverless, aws, devops
Published: 2020-11-17 13:22:01

As you probably already know, Step Functions is a serverless Workflow Service provided by Amazon Web Services (AWS). There's a lot to discuss about this service, and you'll find plenty of vital information in our [AWS Step Functions: The Ultimate Guide](https://dashbird.io/blog/ultimate-guide-aws-step-functions/) as well as in our series of articles that'll dive deep into various aspects regarding this AWS service.

Moreover, if you're eager to learn more about cloud computing, make sure to register for [AWS re:Invent virtual event](https://reinvent.awsevents.com/?trk=em_a134p000006BlQmAAK&trkCampaign=AWS_reInvent_2020&sc_channel=em&sc_campaign=GLOBAL_STRAT_T1_reinvent_DG1_20201130&sc_medium=em_313806&sc_outcome=Strategic_Events&sc_content=AWS_Event&mkt_tok=eyJpIjoiTTJFM1pqUTVPVFZpWkRSaSIsInQiOiJKWTcyRUVPZU1vUzdOM3ptbGlGc2VOT2tKUlF3cjNPS3kxZlp6dEI4YmR2WGxFNEFxMTlIY2krTVdNQWtNSnlhaHMrdGxFd0JPNXBcLzdtRUQ4SEVaNm40V3NJOTVrTXNMczd6Sm1uY1E2cEZhemw2a0thbjdHWThTbkYxRStQblpwWjdyUzdTT0pwUGdDTXRHZ3RFR1lnPT0ifQ%253D%253D) where you'll hear a lot from AWS experts and cloud leaders about what's new and what's coming up next from AWS or feel free to browse our [extensive Knowledge Base](https://dashbird.io/knowledge-base/).

We'll dive deep into Step Functions' benefits and shortcomings in today's article, but our primary focus goes to the best Step Functions use cases.

Quick Reminder About Step Functions
-----------------------------------

Step Functions are utilized with [AWS Lambda](https://dashbird.io/knowledge-base/aws-lambda/introduction-to-aws-lambda/). You'll write little pieces of code into Lambda, and then **you'll stitch them all together with Step Functions**. Moreover, Step Functions provide some advanced capabilities like **multiple task execution** in parallel and then **wait for a specified period of time before proceeding**.

They're quite useful for **orchestrating multiple small tasks** that'll help you build complex workflows. Step Functions are completely [serverless](https://dashbird.io/blog/serverless-bedtime-story/), and this means that users **won't have to worry about scaling up or down** the resources when the incoming requests decrease or increase because **Step functions will take care of it all**.

Now, let's discuss the **benefits** of using Step Functions, so you'll later better understand Step Functions use cases.

Benefits of Using Step Functions
--------------------------------

These are some of the benefits worth mentioning since they'll help you figure out the things that make Step Functions so much important.

### Auto Scaling is Possible

Whenever you come across a drop in incoming requests or a surge, Step Functions will **immediately allocate or deallocate the required resources** for executing the workflows.

### It Has a Modular Code

Considering that the entire business workflow is broken down into small Lambda functions, **every Lambda function focuses on a small, independent piece of logic**. This logic makes the code much more readable. It's also incredibly helpful with writing separate, small, and reusable AWS Lambda functions that can **easily be plugged into different Step Functions**.

### Importance of Maintainability & Testability

Since the logic in every Step Function's Lambda function is small, it's much **easier to write test cases for every one of them**. Moreover, it's vital to know that all Lambda functions can be deployed independently.

### It Allows Development in Various Languages

Because Step Functions communicate with independent Lambda functions, these Lambda functions can** integrate into many supported programming languages like Java, NodeJS, Python**, etc. Therefore, one Step Function can be made out of code written in more than a single language.

### Code Reusability is Possible

Workflows usually involve conditional code execution, which means that if the reimbursement amount is lower than $10 within the reimbursement workflow, it'll be reimbursed directly, or it'll notify *person X*. Therefore, **you'll have to write a single Lambda function to get the reimbursement amount**, another Lambda function that'll **inform a person**, and one more to **do the reimbursement**. After writing these three Lambdas, you can connect them via Conditions within the Step Functions. Now, you can reuse the second Lambda function in any other Step Function to send notifications.

### Step Functions are Resilient

Step Functions can **manage restarts, state, and checkpoints**. They also provide built-in try or catch, rollback, and retry features to help you automatically deal with exceptions or errors.

Challenges of Using Step Functions
----------------------------------

Although we've seen some of the most beneficial aspects of using Step Functions, there are some other areas of concern. For example:

### Self-Service User Interface Isn't Great

While this might not be a shortcoming of Step Functions service per se, the Step Functions **defining console isn't very user-friendly** since it makes it difficult to validate or edit the definitions.

### Pricing Based Per Transition

AWS **charges are based on the number of transitions** happening during the Step Function execution. Therefore, if you have a one-step Step Function, you'll be charged one unit. On the other hand, if you have a complex 30-step function, you'll be charged staggering 30 units per each execution. Since users usually know the number of workflow executions, this method makes it **quite challenging to make initial cost estimations**. In case Step Functions charges were designed to operate per workflow-execution instead of their current charge method (per-state-transition), it might've been much more straightforward.

> Read more about about [how to cut cost on Step Functions](https://dashbird.io/blog/cutting-step-functions-costs-on-enterprise-scale-workflows/).

### Basic Condition Checks

Condition nodes within Step Functions are pretty basic. Since December 2019, they support comparing variables with constants, but you won't be able to compare two variables since this option isn't supported. Therefore, you **won't be able to compare the output of a Lambda function with an input variable, nor you'll be able to compare the output of two Lambda functions.** Additionally, a bit more complex logical conditions don't work either.

Now that you're aware of both upsides and downsides of using Step Functions, we'll turn to actual Step Function use cases.

AWS Step Function Use Cases
---------------------------

AWS Step Functions are **excellent for handling all sorts of workflows** or **processes that require coordination of multiple services to accomplish a higher-level task**. This is especially true in cases where you have to control the information flow and process execution based on results and/or rules from all previous tasks.

These are some workload examples that can bring quite useful results from utilizing Step Functions:

### AI and ETL Jobs

Extract, Transform, and Load (ETL) jobs have become pretty standard in numerous apps and companies. The significant rise of AI and data analytics tools made it almost inevitable to deal with vast amounts of data. It often happens that **all these data points need to be manipulated in multiple steps before becoming analysis-ready**.

![Step Functions: Example of ETL Jobs](https://mk0dashbirdioctwpb7t.kinstacdn.com/wp-content/uploads/2020/11/Screenshot-2020-11-17-at-13.43.40.png)

Step Functions: Example of ETL Jobs

The same goes for Deep Learning and Machine Learning tasks. These tasks **usually involve processing pipelines** in which you have to **follow a series of steps** before **reaching a classification or prediction result**.

Step Functions are excellent for solving these needs since they're connected to other services like AWS Batch or AWS Lambda, and they'll run custom logic upon the data. Moreover, Step Functions will ultimately use DynamoDB and S3 to retrieve and store all information along with workflow processing.

### Orchestrating Microservices

All applications that implement microservices architecture will significantly benefit from Step Functions. What happens is that they'll **simplify the orchestration work**. Composing higher-level tasks is possible, thanks to multiple well-coordinated services in a decoupled but centralized manner.

Rules and complex logic apply to the workflow so they would account for exceptional cases. The "retry mechanism" that's embedded into Step Functions, including integration services like [AWS Lambda](https://dashbird.io/knowledge-base/aws-lambda/introduction-to-aws-lambda/), makes it much **easier to implement composition strategies like fault-tolerant microservices**.

### Parallel Processing (Fan-Out)

Step Functions can also be used for **processing several tasks in parallel or even to control the fan-out process** of tasks that need a breakdown. All this is required so that these tasks could be **tackled in small steps**.

### Datapoint List Handling

Step Functions also **support logic for loops**. You can implement this feature when there's a list of **data points that have to be processed in a similar but independent way**. Moreover, you can design the same workflow for the entire list, but note that Step Functions will process each item sequentially and separately.

Step Functions are excellent in other use case examples as well, and here are the most important ones:

### Very Straightforward Integration with Manual Tasks

AWS Step Functions service is the best solution for **coordinating a workflow requiring manual intervention/approval**. A good example is "Employee Promotion Process." For this process to be completed successfully, it requires the manager's approval. That's where Step Functions comes in. It'll send the email via AWS SES service with a "Approve" or "Reject" link, and once it's received, it'll trigger another action using ECS jobs or Lambda.

### Batch Job Processing

In case your workflow requires sequential processing and data coordination, sequential batch job processing is the best solution. For example, on an e-commerce website, the first job is to access and read the product data, while the next job will discover which products will soon be out of stock, and then, the third job will notify all vendors so they could expedite the upcoming supply process.

![Step Functions: Example of Batch Job Processing](https://mk0dashbirdioctwpb7t.kinstacdn.com/wp-content/uploads/2020/11/Screenshot-2020-11-17-at-13.46.49-1024x448.png)\
Step Functions: Example of Batch Job Processing

### Coordinating Container Tasks in Serverless Workflow

AWS Step Functions are capable of helping you make decisions on how to process the data in the best way possible. By looking at the file size, you can either choose to utilize ECS, Lambda, or even on-premise activity so you could successfully optimize both runtime and the cost.

### **Real-Life Step Function Use Cases**

**Long Sequences:** If your workflow has a long sequence of steps, it means that it's never a good idea to place all the logic in a single codebase. Ordering workflow involves several steps when the user places his order, and the steps are as follows:

Waiting for payment to succeed ---> Generating Invoice ---> Sending email ---> Sending SMS ---> Deducting from Inventory ---> Starting Shipment ---> Creating Tracking Info.

**Async Operations:** You can also check for the completion of async operations by polling. **If your logic is third-party service operation-dependent**, and you don't know how much time it requires, don't wait for the process to complete synchronously. What you should do instead is **trigger a Step Function upon calling the third-party service**. The Step Function can then check the operation status at regular intervals until the successful completion of this operation. Step Function will notify the client when the process is completed successfully.

**Larger companies with multiple teams that work on each step can find it more difficult.** If that's your case, you should **define several Lambda functions for each step and combine them through a single Step function**. Every Lambda function can easily be both developed and maintained by different teams or developers.

**Wrapping Up**

Our final verdict regarding Step Function actual use cases is that it **can come in quite handy by successfully managing business workflows**. The only thing developers have to worry about is the **core logic**, and Step Functions will take care of things like** scaling, hosting, configurations, etc. **Step Functions as a service is still growing, and it may evolve into a perfect solution for any business workflow management in the upcoming years.

Don't forget that you can also [monitor your Step Functions](https://dashbird.io/features/) (both standard and express workflows) with Dashbird and start receiving Well-Architected insights on how to optimize them even better for cost efficiency and operational excellence. You can try it out for free by [signing up here](https://dashbird.io/pricing/). 2-minute easy setup, no credit card required, no code changes and you can cancel any time. *(Psst, we also have an early Black Friday deal: you can use code BLACK2020 an checkout to get your first 2 months for free)*