index.html

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <meta name="title" content="Maestro" />
    <meta
      name="description"
      content="Maestro is a framework for providing rapid iteration for serverless orchestration"
    />
    <meta name="type" content="website" />
    <meta name="url" content="https://maestro-framework.github.io/" />
    <meta
      name="image"
      content="/assets/images/logos/maestro/full-on-light.png"
    />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <meta name="author" content="Torrel Moseley, Zac Klammer, John Isom" />
    <title>Maestro</title>
    <link rel="stylesheet" href="assets/css/fonts.css" />
    <link rel="stylesheet" href="assets/css/main.css" />
    <link
      rel="icon"
      type="image/png"
      sizes="32x32"
      href="assets/images/logos/maestro/favicon.png"
    />
    <link
      rel="stylesheet"
      href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.13.1/styles/dark.min.css"
      charset="utf-8"
    />
    <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/9.13.1/highlight.min.js"></script>
    <script src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
    <script src="assets/scripts/application.js"></script>
    <script src="assets/scripts/slideshow.js"></script>
  </head>
  <body>
    <div class="logo-links">
      <img
        src="assets/images/menu-on-light.png"
        alt="Maestro logo"
        id="menu-logo"
      />
      <a href="https://github.com/maestro-framework/maestro" target="_blank">
        <img
          src="assets/images/icons/github_black.png"
          alt="GitHub logo"
          id="github-logo"
        />
      </a>
    </div>
    <nav id="site-navigation">
      <ul>
        <li>
          <a href="#home" id="home-link">HOME</a>
        </li>
        <li>
          <a href="#case-study" id="case-study-link">CASE STUDY</a>
          <nav id="case-study-mobile">
            <ul></ul>
          </nav>
        </li>
        <li>
          <a href="#our-team" id="our-team-link">OUR TEAM</a>
        </li>
      </ul>
    </nav>
    <header id="home">
      <figure>
        <img
          src="assets/images/logos/maestro/with-subtitle-on-light.png"
          alt="Maestro logo"
        />
      </figure>
    </header>
    <main>
      <!-- for linkedin featured section -->
      <img
        style="display: none;"
        src="assets/images/logos/maestro/mark-on-light.png"
      />
      <!-- normal content now resumes -->

      <section id="case-study">
        <h1>Case Study</h1>

        <nav>
          <ul></ul>
        </nav>

        <h2 id="introduction">1. Introduction</h2>
        <h3>1.1 What is Maestro?</h3>

        <p>
          The rise of serverless architectures and FaaS offerings such as AWS
          Lambda has revolutionized how companies are developing modern apps.
          The need for an orchestration layer over these architectures has
          brought about services such as AWS Step Functions. However, deploying
          apps that use Step Functions can be tedious and error-prone. Maestro
          prioritizes speed and developer productivity by automating this
          process so that the developer’s focus stays on developing their
          application’s business logic.
        </p>

        <p>
          Maestro is an open-source, easy-to-use framework for deploying
          serverless workflows using Node.js® and AWS Step Functions. Using
          Maestro aids development not only in the initial phase of a project
          but throughout the ongoing maintenance as well.
        </p>

        <h2 id="serverless">2. Serverless</h2>

        <p>
          The popularity of developing applications with a serverless approach
          is relatively new. The term “serverless“ seems to imply that servers
          are not involved in an application’s architecture, but that’s not
          accurate. The reason for the term “serverless“ is not because there’s
          an absence of servers, but because the control of the servers has been
          abstracted away and made the responsibility of the cloud provider. So
          from the perspective of the developer, there’s less need to worry
          about maintaining and scaling servers, effectively making their
          architecture serverless.
        </p>

        <p>
          Besides being a bit of a misnomer, the term “serverless“ is also a bit
          overloaded. It encompasses a few different ideas. One of these is what
          is known as Function as a Service (FaaS), or serverless functions.
        </p>

        <h3>2.1 FaaS</h3>

        <p>
          Serverless functions are meant to be small pieces of application code
          that are provisioned in response to some event. Once the event fires,
          a container is spun up in which the function will execute. After
          execution, the container will remain idle for a short amount of time
          in case there are further invocations of the function. If not, the
          container is torn down. This facilitates scaling up and down according
          to demand and only paying for the resources that are used. FaaS is so
          prevalent in serverless architectures that it is often equated with
          the term “serverless“ itself.
        </p>

        <figure>
          <img
            src="assets/images/serverless-poll.svg"
            alt="58% of developers in one poll respond that serverless to them is FaaS"
            title="Serverless Poll"
          />
          <figcaption>
            A recent poll asking developers how they view the term “serverless“
            [<a href="#reference_1" class="reference">1</a>]
          </figcaption>
        </figure>

        <h3>2.2 AWS Lambda</h3>

        <p>
          We’ll be limiting our discussion to a specific cloud provider, Amazon
          Web Services (AWS), as it is by far the most popular provider at this
          time.
        </p>

        <p>
          Amazon’s FaaS offering is known as AWS Lambda. Lambdas are deployed on
          containers that support runtimes in seven languages [<a
            href="#reference_2"
            class="reference"
            >2</a
          >]. Lambdas can be invoked by many AWS services including other
          Lambdas. They have a limited execution of 15 minutes, and any state
          associated with the execution is then lost.
        </p>

        <figure>
          <img
            src="assets/images/logos/aws/lambda.png"
            alt="AWS Lambda Logo"
            title="Lambda"
          />
          <figcaption>AWS Lambda</figcaption>
        </figure>

        <h3>2.3 Serverless Patterns</h3>

        <p>
          As serverless development is still relatively new, best practices have
          yet to be firmly established. However, there are helpful patterns that
          have emerged as developers continue to work with serverless.
        </p>

        <p>
          For example, when a Lambda is initially invoked, its container will
          have to be spun up, usually taking a few hundred milliseconds. This is
          often referred to as a “cold start”. To address this issue, there is a
          pattern called the ‘Function Warmer’, which keeps the Lambda’s
          container available for further invocations. Patterns for working with
          serverless can be grouped into five categories [<a
            href="#reference_3"
            class="reference"
            >3</a
          >].
        </p>

        <ul id="serverless-patterns">
          <li>Availability</li>
          <li>Event Management</li>
          <li>Communication</li>
          <li>Authorization</li>
          <li class="highlight">Orchestration</li>
        </ul>

        <p>
          We’ll be focusing our attention on this last group of patterns:
          Orchestration.
        </p>

        <h2 id="orchestration">3. Orchestration</h2>
        <p>
          Serverless orchestration is the act of managing the workflow between
          multiple serverless resources. To visualize what this might look like,
          let’s consider a hypothetical situation. Let’s say that we’ve been
          assigned a project to create an internal application for our company.
          The app will allow an employee to send a request to their manager,
          asking that a certain resource be provisioned. If the manager
          approves, the resource is provisioned and the employee is granted
          access. Otherwise, the employee is notified that their request has
          been denied.
        </p>

        <figure>
          <img
            src="assets/images/workflow/overview.png"
            alt="Initial components in workflow derived from task"
            title="Thin workflow"
            class="example-workflow"
          />
          <figcaption>
            Example of a serverless workflow with multiple Lambdas
          </figcaption>
        </figure>

        <p>
          Let’s say that the workflow can be implemented by representing each
          component as a Lambda. The work of each Lambda must then be
          orchestrated to ensure that the workflow executes in a meaningful way.
          How will we make sure this workflow proceeds as desired?
        </p>

        <p>
          Let’s assume the ‘Manager’ Lambda will receive an input that contains
          information about the resource being requested. What happens if that
          input is somehow malformed? An error could occur leading to the
          ‘Manager’ failing. Some form of error handling could prevent this, but
          should the ‘Manager’ validate its own input?
        </p>

        <figure>
          <img
            src="assets/images/workflow/validation.png"
            alt="Invalid input"
            class="example-workflow"
          />
          <figcaption>
            We need to consider how to handle an invalid input
          </figcaption>
        </figure>

        <h3>3.1 Orchestration Patterns</h3>

        <p>
          We could introduce a component that has the single responsibility of
          validating input. This would provide a clear separation of concerns
          and would prevent the ‘Manager’ from failing. A common orchestration
          pattern that could be helpful here is known as the ‘Proxy’ [<a
            href="#reference_3"
            class="reference"
            >3</a
          >]. The ‘Proxy’ is a Lambda that sits between two other Lambdas and
          invokes the second one when appropriate. In this case, we could insert
          a ‘Proxy’ Lambda called ‘Validator’ to help handle invalid inputs.
        </p>

        <figure>
          <img
            src="assets/images/workflow/validator.png"
            alt="Inserting a proxy lambda in front of the Manager component"
            title="Proxy Lambda"
            class="example-workflow"
          />
          <figcaption>
            Using the ‘Proxy’ pattern for validating input
          </figcaption>
        </figure>

        <p>
          Next, we need to determine how to properly branch based on the
          ‘Manager’ Lambda’s output.
        </p>

        <figure>
          <img
            src="assets/images/workflow/branching-logic.png"
            alt="Branching step after the Manager makes a decision"
            title="Branching"
            class="example-workflow"
          />
          <figcaption>How will we implement branching logic?</figcaption>
        </figure>

        <p>
          There’s another pattern we could use called the ‘Router’, which simply
          distributes the execution based on payload [<a
            href="#reference_3"
            class="reference"
            >3</a
          >]. Since the ‘Manager’ Lambda can invoke other Lambdas, we can
          implement the ‘Router’ pattern by placing the branching logic there.
          Because we’ve now written orchestration logic alongside business
          logic, we’ll affectionately refer to the ‘Manager’ as the ‘Fat
          Manager’.
        </p>

        <figure>
          <img
            src="assets/images/workflow/fat-manager.png"
            alt="Workflow with the Fat Manager Lambda"
            title="Fat Manager"
            class="example-workflow"
          />
          <figcaption>
            The ‘Manager’ Lambda now contains orchestration logic
          </figcaption>
        </figure>

        <p>
          Now that we’ve taken care of branching, an attempt to provision the
          desired resource can be made. However, the provisioning of a resource
          may be risky. What if the attempt fails for some reason?
        </p>

        <figure>
          <img
            src="assets/images/workflow/provisioning-fail.png"
            alt="Failure depicted on the Provisioner component"
            title="Failed Provisioner"
            class="example-workflow"
          />
          <figcaption>The provisioning step fails…</figcaption>
        </figure>

        <p>
          We’d like to prevent the employee from having to repeat their request
          such that the workflow has to start over. To address this, we could
          once again apply the ‘Router’ pattern. This time, we’ll add logic to
          the ‘Manager’ so that it monitors the output of the ‘Provisioner’. If
          the ‘Manager’ detects that the provisioning has failed, we can have it
          invoke the ‘Provisioner’ again. But how many retries do we want to
          allow? How quickly do we want to retry? This is further orchestration
          logic that we’ll have to write into the ‘Manager’, making it even
          fatter.
        </p>

        <figure>
          <img
            src="assets/images/workflow/fatter-manager.png"
            alt="Addition of retry to the Fat Manager Lambda"
            title="Fat Manager with Retry"
            class="example-workflow"
          />
          <figcaption>
            The ‘Manager’ Lambda with even more orchestration responsibility
          </figcaption>
        </figure>

        <p>
          Do any limitations exist with this implementation? The probability of
          the Lambda surpassing its execution limit is now increased if the
          ‘Manager’ monitors the ‘Provisioner’ and there are multiple retries.
          Delayed provisioning may cause the ‘Manager’ to terminate before
          determining if a retry was necessary. Further, with the orchestration
          logic of the ‘Manager’ written alongside the business logic, the
          component is overloaded resulting in poor separation of concerns.
        </p>

        <figure>
          <img
            src="assets/images/workflow/everything.png"
            alt="Overloaded Workflow"
            class="example-workflow"
          />
          <figcaption>Workflow overloaded with orchestration logic</figcaption>
        </figure>

        <p>
          The consequences of not separating concerns would be felt every time
          it’s necessary to iterate on the workflow. Business logic as well as
          orchestration logic may need to be evaluated and adapted for the
          application to grow.
        </p>

        <p>
          Perhaps refactoring is in order. Maybe it would be wise to extract the
          orchestration logic to a separate component other than the ‘Manager’.
          If that intuition seems natural, can more be done?
        </p>

        <p>
          Why not extract out an entire orchestration layer? The result would be
          a thin workflow of strictly business logic resembling the original
          workflow. The orchestration logic would be entirely on its own.
        </p>

        <figure>
          <img
            src="assets/images/workflow/orchestration-layer.png"
            alt="Diagram of only the orchestration layer in a workflow"
            title="Orchestration Layer"
            class="example-workflow"
          />
          <figcaption>
            An orchestration layer abstracted from the workflow
          </figcaption>
        </figure>

        <p>
          By implementing the application in this way, we’re able to orchestrate
          error handling, retry, and branching all in one place. When the
          business logic needs to be modified, the orchestration logic can
          likely stay the same. This can be quite valuable for a new application
          or one that simply hasn’t reached a stable state.
        </p>

        <p>
          So how would we go about extracting an orchestration layer? Creating
          and maintaining custom logic would require considerable overhead.
          Let’s look at another pattern called the ‘State Machine’ [<a
            href="#reference_3"
            class="reference"
            >3</a
          >] to see whether it might be suitable for our needs.
        </p>

        <h3>3.2 The State Machine Pattern</h3>

        <blockquote cite="https://www.serverlesschats.com/16/">
          <p>
            "State machines are really just a mathematical way of modeling an
            application.…[With state machines,] you can describe your
            application as a mixture of your
            <span class="highlight">inputs</span>, the
            <span class="highlight">states</span> that your application can be
            in, and the <span class="highlight">transitions</span> between those
            states."
          </p>
          <footer>
            Rowan Udell,
            <cite
              >Serverless Chats Podcast – Episode #16 [<a
                href="#reference_4"
                class="reference"
                >4</a
              >]</cite
            >
          </footer>
        </blockquote>

        <p>
          It’s important to note that a state machine is not a physical device
          but an abstract concept. A state machine is all about inputs, outputs,
          transitions, and state, making it an ideal candidate for an
          orchestration layer. But how would we go about implementing a state
          machine? It just so happens that AWS offers a “State Machine as a
          Service” called AWS Step Functions.
        </p>

        <h2 id="aws-step-functions">4. AWS Step Functions</h2>

        <blockquote
          cite="https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html"
        >
          <p>
            “AWS Step Functions is a web service that enables you to coordinate
            the components of distributed applications and microservices using
            visual workflows. You build applications from individual components
            that each perform a discrete function, or task, allowing you to
            scale and
            <span class="highlight">change applications quickly</span>.”
          </p>
          <footer>
            AWS Documentation,
            <cite
              >What is AWS Step Functions? [<a
                href="#reference_5"
                class="reference"
                >5</a
              >]</cite
            >
          </footer>
        </blockquote>

        <figure>
          <img
            src="assets/images/logos/aws/step-functions.png"
            alt="AWS Step Functions Logo"
            title="Step Functions Logo"
          />
          <figcaption>AWS Step Functions</figcaption>
        </figure>

        <p>
          Step Functions are designed to contain an application’s orchestration
          logic. This helps us to maintain the separation of concerns that we
          mentioned earlier. To create a state machine with Step Functions,
          we’ll need to use the JSON-based language called Amazon States
          Language (ASL).
        </p>

        <h3>4.1 Amazon States Language</h3>

        <p>
          Let’s first look at a “Hello World” state machine definition to
          familiarize ourselves with ASL.
        </p>

        <figure>
          <div class="flex">
            <pre>
              <code class="js dark">
{
  "StartAt": "Hello World",
  "States": {
    "Hello": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:hello",
      "Next": "World"
    },
    "World": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:world",
      "End": true
    }
  }
}
              </code>
            </pre>
            <img
              class="maestro-border"
              src="assets/images/step-functions-console/hello-world.png"
              alt="Example of the ASL of a workflow for a Hello World Application"
              title="Hello World ASL "
            />
          </div>
          <figcaption>
            A state machine definition with a visual that is displayed in the
            AWS Management Console
          </figcaption>
        </figure>

        <p>
          There are two top-level fields required for all state machines:
          <code>StartAt</code> and <code>States</code>. The
          <code>StartAt</code> field simply designates which state will begin
          execution, whereas the <code>States</code> field is a list of all
          possible states. Once a valid definition is entered in the AWS
          Management Console, a visual that represents the state machine will be
          displayed.
        </p>

        <p>
          A state‘s type dictates the additional attributes that the state can
          have. There are eight different state types given to us by ASL.
        </p>

        <ul>
          <li><code>Task</code></li>
          <li><code>Parallel</code></li>
          <li><code>Map</code></li>
          <li><code>Pass</code></li>
          <li><code>Wait</code></li>
          <li><code>Choice</code></li>
          <li><code>Succeed</code></li>
          <li><code>Fail</code></li>
        </ul>

        <p>
          The <code>Task</code> type allows a state to reference a Lambda
          function. This is done by setting the state‘s
          <code>Resource</code> field to the Lambda‘s Amazon Resource Name
          (ARN). We see that the “Hello World” example has two
          <code>Task</code> states: <code>Hello</code> and <code>World</code>,
          each of which points to a different Lambda. When
          <code>Hello</code> returns, its output is passed as input to the next
          (and last) step in the execution, <code>World</code>.
        </p>

        <p>
          The other state types do not map to Lambda functions but help with
          workflow orchestration. For example, the <code>Choice</code> state
          enables branching logic and the <code>Wait</code> state will pause
          execution for some specified amount of time.
        </p>

        <p>
          Let’s return to our earlier example of an employee requesting approval
          for a resource to be provisioned. We’ll now implement this workflow
          with Step Functions.
        </p>

        <figure>
          <div class="flex">
            <pre>
              <code class="js dark">
{
  "StartAt": "Requester",
  "States": {
    "Requester": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:WORKFLOW_NAME_requester",
      "Next": "Manager"
    },
    "Manager": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:WORKFLOW_NAME_manager",
      "Next": "ManagerChoice"
    },
    "ManagerChoice": {
      "Type": "Choice",
      "Choices": [
        {
          "Variable": "$.decision",
          "StringEquals": "accept",
          "Next": "Provisioner"
        },
        {
          "Variable": "$.decision",
          "StringEquals": "deny",
          "Next": "Notifier"
        }
      ]
    },
    "Provisioner": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:WORKFLOW_NAME_provisioner",
      "Next": "AccessGranter",
      "Retry": [
        {
          "ErrorEquals": ["States.ALL"],
          "IntervalSeconds": 2,
          "BackoffRate": 1.5,
          "MaxAttempts": 5
        }
      ],
      "Catch": [
        {
          "ErrorEquals": ["States.ALL"],
          "ResultPath": "$.errorInfo",
          "Next": "Notifier"
        }
      ]
    },
    "AccessGranter": {
      "Type": "Pass",
      "Next": "Notifier"
    },
    "Notifier": {
      "Type": "Pass",
      "End": true
    }
  }
}

              </code>
            </pre>
            <img
              src="assets/images/step-functions-console/example-workflow.png"
              alt="Visualization of example workflow in AWS Management Console"
            />
          </div>
          <figcaption>
            Earlier example now implemented with AWS Step Functions
          </figcaption>
        </figure>

        <p>
          One of the states, <code>Provisioner</code>, is mapped to the Lambda
          that handles resource provisioning. Looking more closely at this
          state, we see how one might implement retry logic.
          <code>Task</code> states have an optional field called
          <code>Retry</code> that will specify which types of errors to retry,
          how many seconds to wait in between, as well as a backoff rate and a
          maximum number of attempts. It’s useful to be able to put this
          orchestration concern here, instead of writing some custom retry logic
          alongside business logic.
        </p>

        <figure>
          <div class="flex">
            <pre>
              <code class="js dark">
//…
"Provisioner": {
  "Type": "Task",
  "Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:provisioner",
  "Next": "AccessGranter",
  "Retry": [
    {
      "ErrorEquals": ["States.ALL"],
      "IntervalSeconds": 2,
      "BackoffRate": 1.5,
      "MaxAttempts": 5
    }
  ],
  //…
},

              </code>
            </pre>
          </div>
          <figcaption>Provisioner state showing retry logic in ASL</figcaption>
        </figure>

        <h3>4.2 Execution Event History</h3>

        <p>
          Once a state machine has executed, using the AWS Management Console,
          we’re able to access an interactive execution event history. This
          allows us to audit the transitions between states in one, unified
          place.
        </p>

        <figure>
          <img
            class="maestro-border"
            src="assets/images/step-functions-console/logs.gif"
            alt="Execution event history"
          />
          <figcaption>
            Execution Event History in the AWS Management Console
          </figcaption>
        </figure>

        <p>
          Additionally, the visual workflow will be color-coded to help us
          quickly remember the outcome of each state for that execution. This
          interface is updated in real-time, which can be helpful when viewing
          the status of longer-running state machines.
        </p>

        <figure>
          <img
            class="maestro-border"
            src="assets/images/step-functions-console/execution.gif"
            alt="Visualization of an executing state machine in the AWS Management Console"
          />
          <figcaption>
            An executing state machine in the AWS Management Console
          </figcaption>
        </figure>

        <p>
          The core purpose of AWS Step Functions is to provide an orchestration
          layer, preventing us from having to somehow choreograph our
          application’s resources. Step Functions also provides many built-in
          features, such as eight state types, unified logs, and visual
          workflows that can help when needing to audit executions.
        </p>

        <p>
          Despite these benefits, some challenges arise when choosing to develop
          with Step Functions. Let’s examine some of these problems.
        </p>

        <h2 id="problems">5. Problems</h2>
        <h3>5.1 Programming Model</h3>

        <p>
          One of the common complaints with Step Functions is that ASL is not
          very intuitive.
        </p>

        <blockquote
          cite="https://www.serverless.com/aws-step-functions#drawbacks"
        >
          <p>
            Amazon States Language is quite complex; its syntax is based on JSON
            and therefore
            <span class="highlight">optimized for machine readability</span>
            instead of readability by humans.
          </p>
          <footer>
            Article from
            <cite
              >Serverless Framework [<a href="#reference_6" class="reference"
                >6</a
              >]
            </cite>
          </footer>
        </blockquote>

        <p>
          Imagine creating a state machine with dozens or even hundreds of
          states.
        </p>

        <blockquote
          cite="https://research.chalmers.se/publication/508147/file/508147_Fulltext.pdf"
        >
          <p>
            “ ‘…
            <span class="highlight"
              >Nobody wants to write JSON format for a state machine that has
              hundreds of states</span
            >.’ -Interviewee 1
          </p>
          <p>
            There is an expectation that, in the future, higher-level
            abstractions will be developed and current technologies, such as
            Lambda and Step Functions, will become mere deployment platforms,
            which are
            <span class="highlight">not intended to be programmed directly</span
            >.”
          </p>
          <footer>
            Philipp Leitner et al. –
            <cite
              >Paper from Chalmers University of Technology [<a
                href="#reference_1"
                class="reference"
                >1</a
              >]</cite
            >
          </footer>
        </blockquote>

        <p>
          Several tools attempt to provide higher-level abstractions that
          compile down to ASL. However, none has been widely adopted and there
          is still unsettled debate regarding the characteristics of these tools
          [<a href="reference_7" class="reference">7</a>].
        </p>

        <p>
          It seems that, for now, the most effective way to alleviate the pain
          of working with ASL is to use templates. This at least provides a
          useful starting point for developers new to Step Functions and is a
          nice convenience for those who are more familiar with ASL.
        </p>

        <h3>5.2 Deployment</h3>

        <p>
          The AWS Management Console’s tagline is “Everything you need to access
          and manage the AWS cloud — in one web interface.” [<a
            href="reference_8"
            class="reference"
            >8</a
          >]
        </p>

        <figure>
          <img
            src="assets/images/logos/aws/management-console.png"
            alt="AWS Management Console"
          />
          <figcaption>AWS Management Console</figcaption>
        </figure>

        <p>
          Let’s look at the steps involved to deploy our example workflow using
          only the AWS Management Console.
        </p>

        <figure>
          <img
            src="assets/images/hazy-diagrams/full.png"
            alt="Resources to be deployed manually"
          />
          <figcaption>
            Deploying our example workflow with the AWS Management Console
          </figcaption>
        </figure>

        <p>
          The Management Console indeed provides everything needed for managing
          the AWS cloud. But it also requires extensive configuration and
          navigation – pointing, clicking, reloading of the screen, often in a
          rigid order. The three Lambdas in our workflow all have to go through
          the same tedious process. Imagine if our example had included ten or
          more Lambdas.
        </p>

        <p>
          Although the Management Console touts itself as “one web interface”,
          each of the AWS services has a different flavor of that interface with
          distinct concepts and interactions. Each service must be configured
          with the correct region and account number and must be assigned
          security roles with the proper execution permissions. Also, an account
          that contains multiple applications will list all services of the same
          kind alongside one another, mingling the resources of separate
          applications together.
        </p>

        <figure>
          <img
            src="assets/images/aws-services-diagram.png"
            alt="The AWS Management Console has many interfaces"
          />
          <figcaption>
            The AWS Management Console encapsulates several different services
          </figcaption>
        </figure>

        <p>
          What would it look like if we decided to tear down our state machine
          and its associated Lambdas? It would be a similar, error-prone process
          but in reverse order. This is not conducive to quickly developing a
          new workflow that requires frequent iteration.
        </p>

        <p>
          The manual tedium of deploying to the AWS cloud using only the
          Management Console is a process that should be automated. Fortunately,
          several serverless deployment frameworks aim to do just that.
        </p>

        <h2 id="existing-solutions">6. Existing Solutions</h2>

        <p>
          A framework for deploying to AWS will typically be built using one of
          two AWS tools. Let’s first understand a bit about these tools before
          examining any specific frameworks.
        </p>

        <p>
          The first one we’ll look at is called AWS CloudFormation [<a
            href="#reference_9"
            class="reference"
            >9</a
          >]. With this approach, a framework can guide us through a process of
          creating framework-specific files that are then compiled to a single
          CloudFormation config file. All our serverless resources can then be
          deployed using this file. Frameworks that aim to be more
          general-purpose often take the CloudFormation approach.
        </p>

        <figure>
          <img
            src="assets/images/logos/aws/cloud-formation.png"
            alt="CloudFormation Logo"
          />
          <figcaption>AWS CloudFormation</figcaption>
        </figure>

        <p>
          The other tool is the AWS Software Development Kit (SDK) [<a
            href="#reference_10"
            class="reference"
            >10</a
          >]. This is a collection of APIs that allow us to work directly with
          individual resources from our language of choice. Frameworks geared
          toward a specific use case or a particular language are usually built
          with the SDK.
        </p>

        <figure>
          <img src="assets/images/logos/aws/sdks.png" alt="AWS SDK Logo" />
          <figcaption>AWS SDK</figcaption>
        </figure>

        <p>
          Let’s now examine some specific frameworks, keeping in mind that we’ll
          only be considering those that support Step Functions.
        </p>

        <h3>6.1 Serverless Framework</h3>

        <p>
          The aptly named Serverless Framework [<a
            href="#reference_11"
            class="reference"
            >11</a
          >] is the dominant player in this space. It supports deployment to
          many cloud providers and in several different languages.
        </p>

        <figure>
          <img
            src="assets/images/logos/serverless-framework.png"
            alt="Serverless Framework logo"
          />
          <figcaption>Serverless Framework</figcaption>
        </figure>

        <p>
          Serverless Framework has an active community that has created over two
          thousand open-source plugins [<a
            href="#reference_12"
            class="reference"
            >12</a
          >]. One of these plugins enables support for Step Functions.
        </p>

        <p>
          There are some common state machine templates available at the bottom
          of the plugin’s <code>README</code> [<a
            href="#reference_13"
            class="reference"
            >13</a
          >]. While this is helpful, it would be nice to be able to create a new
          project based on a certain template without having to copy and paste
          from the <code>README</code>. Also, to accommodate Serverless
          Framework’s conventions, the state machine must be written in YAML.
          This is unfortunate since ASL is a JSON-based language.
        </p>

        <h3>6.2 AWS SAM</h3>

        <p>
          Amazon provides a framework for serverless deployment called the AWS
          Serverless Application Model (SAM) [<a
            href="#reference_14"
            class="reference"
            >14</a
          >]. SAM started providing support for Step Functions just a few months
          before this writing [<a href="#reference_15" class="reference">15</a
          >].
        </p>

        <figure>
          <img src="assets/images/logos/aws/sam.png" alt="AWS SAM logo" />
          <figcaption>AWS SAM</figcaption>
        </figure>

        <p>
          Unlike Serverless Framework, SAM can deploy a working state machine
          from a template, without having to make any manual configurations – it
          can all be done straight from the CLI. However, there is only one
          template that is offered and it has a relatively lengthy deployment
          time, taking about three minutes. There are also several prompts that
          the user must respond to during this process. Once deployed, there
          doesn’t seem to be a command that just as easily tears down, so that
          must be done manually.
        </p>

        <p>
          It’s important to note that neither Serverless Framework nor SAM was
          designed with Step Functions in mind. They both later added support
          for Step Functions for apps that happen to use them. And because of
          their general-purpose nature, these frameworks carry around a lot of
          tooling, which may be unnecessary and bulky for simpler workflows.
        </p>

        <h3>6.3 Step</h3>

        <p>
          What about more purpose-built frameworks that use the SDK?
          Unfortunately, there don’t seem to be many specifically designed for
          Step Functions. There is one built by Coinbase called Step, which is
          “a framework for building, testing, and deploying AWS Step Functions
          and Lambda”. [<a href="#reference_16" class="reference">16</a>].
        </p>

        <figure>
          <img src="assets/images/logos/step.png" alt="Step Logo" />
          <figcaption>Step</figcaption>
        </figure>

        <p>
          Step allows the user to construct a state machine definition with a
          higher-level language, namely Go. However, Coinbase seems to be one of
          the only users of their framework. Indeed, the development status of
          the framework is listed as Beta. An additional drawback is that Step
          is not able to create a new state machine but can only modify an
          existing one. This can be a hindrance to the developer who is wanting
          to quickly iterate on their work but has to manually create a mock
          state machine first.
        </p>

        <p>
          While the above solutions provide some helpful ways to manage Step
          Functions, we found them lacking in some important areas. Because of
          this, we decided to build Maestro.
        </p>

        <h2 id="maestro">7. Maestro</h2>

        <p>
          Maestro is an open-source framework for AWS Step Functions built with
          ease of use in mind. It offers simple commands that facilitate common
          operations for applications that are suited for Step Functions,
          including interactions with AWS.
        </p>

        <p>
          Once Maestro has been installed and configured, deploying a state
          machine is a simple process. Create a new Maestro project, optionally
          edit the state machine template, and then type one command to deploy
          the state machine and any Lambda functions it includes. One could say
          that it’s as easy as 1, 2, 3.
        </p>

        <figure>
          <img
            src="assets/images/step-functions-console/console-diagram-7.gif"
            style="max-height: 50vh;"
            alt="deploying with maestro"
          />
          <figcaption>Steps of deploying with Maestro</figcaption>
        </figure>

        <p>
          To fully demonstrate the power of Maestro, first consider this
          slideshow that shows in detail the steps required to deploy our
          example workflow using just the AWS Management Console:
        </p>

        <figure id="console-slideshow" class="slideshow">
          <svg viewBox="0 0 50 70" class="prev-button" sytle="display: none;">
            <polygon points="50, 0 0, 35 50, 70" />
          </svg>
          <svg viewBox="0 0 50 70" class="next-button" sytle="display: none;">
            <polygon points="0, 0 50, 35 0, 70" />
          </svg>
          <noscript>
            <aside>
              <small>
                To view an interactive slideshow, you must enable JavaScript.
              </small>
            </aside>
          </noscript>
          <div class="slideshow-items">
            <figure>
              <img
                src="assets/images/console-slideshow/01.png"
                alt="Screenshot of the AWS Management Console and opening the “Services” dropdown"
              />
              <figcaption>
                1: Screenshot of the AWS Management Console and opening the “Services”
                dropdown
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/02.png"
                alt="Screenshot of the “Services” dropdown menu and clicking the “Step Functions” hyperlink"
              />
              <figcaption>
                2: Screenshot of the “Services” dropdown menu and clicking the
                “Step Functions” hyperlink
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/03.png"
                alt="Screenshot of opening sidebar"
              />
              <figcaption>3: Screenshot of opening sidebar</figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/04.png"
                alt="Screenshot of selecting “State machines”"
              />
              <figcaption>
                4: Screenshot of selecting “State machines”
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/05.png"
                alt="Screenshot of clicking the “Create state machine” button"
              />
              <figcaption>
                5: Screenshot of clicking the “Create state machine” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/06.png"
                alt="Screenshot of opening the “Services” dropdown"
              />
              <figcaption>
                6: Screenshot of opening the “Services” dropdown
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/07.png"
                alt="Screenshot of opening the “Lambda” page in a new tab (by control-clicking the hyperlink)"
              />
              <figcaption>
                7: Screenshot of opening the “Lambda” page in a new tab (by
                control-clicking the hyperlink)
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/08.png"
                alt="Screenshot of navigating back to the “Step Functions“ tab"
              />
              <figcaption>
                8: Screenshot of navigating back to the “Step Functions“ tab
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/09.png"
                alt="Screenshot of the state machine definition editor"
              />
              <figcaption>
                9: Screenshot of the state machine definition editor
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/10.png"
                alt="Screenshot of incremental edit of state machine definition"
              />
              <figcaption>
                10: Screenshot of incremental edit of state machine definition
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/11.png"
                alt="Screenshot of incremental edit of state machine definition"
              />
              <figcaption>
                11: Screenshot of incremental edit of state machine definition
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/12.png"
                alt="Screenshot of incremental edit of state machine definition"
              />
              <figcaption>
                12: Screenshot of incremental edit of state machine definition
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/13.png"
                alt="Screenshot of incremental edit of state machine definition"
              />
              <figcaption>
                13: Screenshot of incremental edit of state machine definition
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/14.png"
                alt="Screenshot of incremental edit of state machine definition"
              />
              <figcaption>
                14: Screenshot of incremental edit of state machine definition
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/15.png"
                alt="Screenshot of incremental edit of state machine definition and clicking the “Next” button"
              />
              <figcaption>
                15: Screenshot of incremental edit of state machine definition
                and clicking the “Next” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/16.png"
                alt="Screenshot of: 1) error thrown upon attempted save; and 2) navigating to the “Lambda” tab"
              />
              <figcaption>
                16: Screenshot of: 1) error thrown upon attempted save; and 2)
                navigating to the “Lambda” tab
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/17.png"
                alt="Screenshot of clicking the “Create function” button"
              />
              <figcaption>
                17: Screenshot of clicking the “Create function” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/18.png"
                alt="Screenshot of filling out a “Function name” form field"
              />
              <figcaption>
                18: Screenshot of filling out a “Function name” form field
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/19.png"
                alt="Screenshot of selecting the runtime by using a select form field"
              />
              <figcaption>
                19: Screenshot of selecting the runtime by using a select form
                field
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/20.png"
                alt="Screenshot of selecting the runtime by using a select form field"
              />
              <figcaption>
                20: Screenshot of selecting the runtime by using a select form
                field
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/21.png"
                alt="Screenshot of clicking the “Create function” button"
              />
              <figcaption>
                21: Screenshot of clicking the “Create function” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/22.png"
                alt="Screenshot of scrolling down to view the function code"
              />
              <figcaption>
                22: Screenshot of scrolling down to view the function code
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/23.png"
                alt="Screenshot of edit to the function code"
              />
              <figcaption>
                23: Screenshot of edit to the function code
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/24.png"
                alt="Screenshot of edit to the function code and clicking the “Save” button"
              />
              <figcaption>
                24: Screenshot of edit to the function code and clicking the
                “Save” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/25.png"
                alt="Screenshot of copying the arn"
              />
              <figcaption>25: Screenshot of copying the arn</figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/26.png"
                alt="Screenshot of: 1) copying the arn; and 2) navigating to the “Step Functions“ tab"
              />
              <figcaption>
                26: Screenshot of: 1) copying the arn; and 2) navigating to the
                “Step Functions“ tab
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/27.png"
                alt="Screenshot of scrolling the view of the state machine definition"
              />
              <figcaption>
                27: Screenshot of scrolling the view of the state machine
                definition
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/28.png"
                alt="Screenshot of pasting the arn into the definition"
              />
              <figcaption>
                28: Screenshot of pasting the arn into the definition
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/29.png"
                alt="Screenshot of navigating to the “Lambda” tab"
              />
              <figcaption>
                29: Screenshot of navigating to the “Lambda” tab
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/30.png"
                alt="Screenshot of navigating to the “Functions” page by clicking a hyperlink"
              />
              <figcaption>
                30: Screenshot of navigating to the “Functions” page by clicking
                a hyperlink
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/31.png"
                alt="Screenshot of: 1) noticing the new function is listed among the existing functions; and 2) clicking the “Create function” button"
              />
              <figcaption>
                31: Screenshot of: 1) noticing the new function is listed among
                the existing functions; and 2) clicking the “Create function”
                button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/32.png"
                alt="Screenshot of filling out all the form fields and clicking the “Create function” button"
              />
              <figcaption>
                32: Screenshot of filling out all the form fields and clicking
                the “Create function” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/33.png"
                alt="Screenshot of scrolling down to view the function code"
              />
              <figcaption>
                33: Screenshot of scrolling down to view the function code
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/34.png"
                alt="Screenshot of edit to the function code and clicking the “Save” button"
              />
              <figcaption>
                34: Screenshot of edit to the function code and clicking the
                “Save” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/35.png"
                alt="Screenshot of copying the arn"
              />
              <figcaption>35: Screenshot of copying the arn</figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/36.png"
                alt="Screenshot of: 1) copying the arn; and 2) navigating to the “Step Functions“ tab"
              />
              <figcaption>
                36: Screenshot of: 1) copying the arn; and 2) navigating to the
                “Step Functions“ tab
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/37.png"
                alt="Screenshot of pasting the arn into the definition"
              />
              <figcaption>
                37: Screenshot of pasting the arn into the definition
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/38.png"
                alt="Screenshot of navigating to the “Lambda” tab"
              />
              <figcaption>
                38: Screenshot of navigating to the “Lambda” tab
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/39.png"
                alt="Screenshot of navigating to the “Functions” page by clicking a hyperlink"
              />
              <figcaption>
                39: Screenshot of navigating to the “Functions” page by clicking
                a hyperlink
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/40.png"
                alt="Screenshot of: 1) noticing the new function is listed among the existing functions; and 2) clicking the “Create function” button"
              />
              <figcaption>
                40: Screenshot of: 1) noticing the new function is listed among
                the existing functions; and 2) clicking the “Create function”
                button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/41.png"
                alt="Screenshot of filling out all the form fields and clicking the “Create function” button"
              />
              <figcaption>
                41: Screenshot of filling out all the form fields and clicking
                the “Create function” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/42.png"
                alt="Screenshot of waiting for the form to submit"
              />
              <figcaption>
                42: Screenshot of waiting for the form to submit
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/43.png"
                alt="Screenshot of scrolling down to view the function code"
              />
              <figcaption>
                43: Screenshot of scrolling down to view the function code
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/44.png"
                alt="Screenshot of edit to the function code and clicking the “Save” button"
              />
              <figcaption>
                44: Screenshot of edit to the function code and clicking the
                “Save” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/45.png"
                alt="Screenshot of copying the arn"
              />
              <figcaption>45: Screenshot of copying the arn</figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/46.png"
                alt="Screenshot of: 1) copying the arn; and 2) navigating to the “Step Functions“ tab"
              />
              <figcaption>
                46: Screenshot of: 1) copying the arn; and 2) navigating to the
                “Step Functions“ tab
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/47.png"
                alt="Screenshot of pasting the arn into the definition"
              />
              <figcaption>
                47: Screenshot of pasting the arn into the definition
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/48.png"
                alt="Screenshot of scrolling the view of the state machine definition"
              />
              <figcaption>
                48: Screenshot of scrolling the view of the state machine
                definition
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/49.png"
                alt="Screenshot of: 1) noticing that another arn needs to be provided; and 2) navigating to the “Lambda” tab"
              />
              <figcaption>
                49: Screenshot of: 1) noticing that another arn needs to be
                provided; and 2) navigating to the “Lambda” tab
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/50.png"
                alt="Screenshot of navigating to the “Functions” page by clicking a hyperlink"
              />
              <figcaption>
                50: Screenshot of navigating to the “Functions” page by clicking
                a hyperlink
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/51.png"
                alt="Screenshot of: 1) noticing the new function is listed among the existing functions; and 2) clicking the “Create function” button"
              />
              <figcaption>
                51: Screenshot of: 1) noticing the new function is listed among
                the existing functions; and 2) clicking the “Create function”
                button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/52.png"
                alt="Screenshot of filling out all the form fields and clicking the “Create function” button"
              />
              <figcaption>
                52: Screenshot of filling out all the form fields and clicking
                the “Create function” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/53.png"
                alt="Screenshot of waiting for the form to submit"
              />
              <figcaption>
                53: Screenshot of waiting for the form to submit
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/54.png"
                alt="Screenshot of scrolling down to view the function code"
              />
              <figcaption>
                54: Screenshot of scrolling down to view the function code
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/55.png"
                alt="Screenshot of edit to the function code and clicking the “Save” button"
              />
              <figcaption>
                55: Screenshot of edit to the function code and clicking the
                “Save” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/56.png"
                alt="Screenshot of copying the arn"
              />
              <figcaption>56: Screenshot of copying the arn</figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/57.png"
                alt="Screenshot of: 1) copying the arn; and 2) navigating to the “Step Functions“ tab"
              />
              <figcaption>
                57: Screenshot of: 1) copying the arn; and 2) navigating to the
                “Step Functions“ tab
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/58.png"
                alt="Screenshot of pasting the arn into the definition"
              />
              <figcaption>
                58: Screenshot of pasting the arn into the definition
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/59.png"
                alt="Screenshot of clicking the “Next” button"
              />
              <figcaption>
                59: Screenshot of clicking the “Next” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/60.png"
                alt="Screenshot of: 1) filling out a “State machine name” form field; and 2) scrolling the view downwards"
              />
              <figcaption>
                60: Screenshot of: 1) filling out a “State machine name” form
                field; and 2) scrolling the view downwards
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/61.png"
                alt="Screenshot of clicking the “Create state machine” button and waiting for the form to submit"
              />
              <figcaption>
                61: Screenshot of clicking the “Create state machine” button and
                waiting for the form to submit
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/62.png"
                alt="Screenshot of clicking the “Definition” tab (webpage UI tab, not browser tab)"
              />
              <figcaption>
                62: Screenshot of clicking the “Definition” tab (webpage UI tab,
                not browser tab)
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/63.png"
                alt="Screenshot of state machine definition"
              />
              <figcaption>
                63: Screenshot of state machine definition
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/64.png"
                alt="Screenshot of clicking the “Executions” tab (webpage UI tab, not browser tab)"
              />
              <figcaption>
                64: Screenshot of clicking the “Executions” tab (webpage UI tab,
                not browser tab)
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/65.png"
                alt="Screenshot of clicking the “Start execution” button"
              />
              <figcaption>
                65: Screenshot of clicking the “Start execution” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/66.png"
                alt="Screenshot of execution input text field"
              />
              <figcaption>
                66: Screenshot of execution input text field
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/67.png"
                alt="Screenshot of edit to input text and clicking the “Start execution” button"
              />
              <figcaption>
                67: Screenshot of edit to input text and clicking the “Start
                execution” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/68.png"
                alt="Screenshot of execution in progress"
              />
              <figcaption>68: Screenshot of execution in progress</figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/69.png"
                alt="Screenshot of execution completed"
              />
              <figcaption>69: Screenshot of execution completed</figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/70.png"
                alt="Screenshot of scrolling view downwards"
              />
              <figcaption>
                70: Screenshot of scrolling view downwards
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/71.png"
                alt="Screenshot of expanding an “Execution event history” log row by clicking the triangular expansion button"
              />
              <figcaption>
                71: Screenshot of expanding an “Execution event history” log row
                by clicking the triangular expansion button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/72.png"
                alt="Screenshot of scrolling view downwards"
              />
              <figcaption>
                72: Screenshot of scrolling view downwards
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/73.png"
                alt="Screenshot of more expanded “Execution event history” log rows and scrolling view to top of the web page"
              />
              <figcaption>
                73: Screenshot of more expanded “Execution event history” log
                rows and scrolling view to top of the web page
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/74.png"
                alt="Screenshot of clicking on a step in the visual workflow"
              />
              <figcaption>
                74: Screenshot of clicking on a step in the visual workflow
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/75.png"
                alt="Screenshot of input and output associated with the step and clicking on an additional step in the visual workflow"
              />
              <figcaption>
                75: Screenshot of input and output associated with the step and
                clicking on an additional step in the visual workflow
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/76.png"
                alt="Screenshot of input and output associated with the step"
              />
              <figcaption>
                76: Screenshot of input and output associated with the step
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/77.png"
                alt="Screenshot of clicking on the “State machines” breadcrumb navigation link"
              />
              <figcaption>
                77: Screenshot of clicking on the “State machines” breadcrumb
                navigation link
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/78.png"
                alt="Screenshot of selecting the state machine and clicking the “Delete” button"
              />
              <figcaption>
                78: Screenshot of selecting the state machine and clicking the
                “Delete” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/79.png"
                alt="Screenshot of clicking the “Delete state machine” button on a confirmation popup dialog"
              />
              <figcaption>
                79: Screenshot of clicking the “Delete state machine” button on
                a confirmation popup dialog
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/80.png"
                alt="Screenshot of: 1) noticing that the status of the state machine now says “Deleting”; and 2) navigating to the “Lambda” browser tab"
              />
              <figcaption>
                80: Screenshot of: 1) noticing that the status of the state
                machine now says “Deleting”; and 2) navigating to the “Lambda”
                browser tab
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/81.png"
                alt="Screenshot of: 1) selecting a function resource; and 2) clicking on the “Actions” dropdown menu"
              />
              <figcaption>
                81: Screenshot of: 1) selecting a function resource; and 2)
                clicking on the “Actions” dropdown menu
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/82.png"
                alt="Screenshot of clicking the “Delete” option from the dropdown menu"
              />
              <figcaption>
                82: Screenshot of clicking the “Delete” option from the dropdown
                menu
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/83.png"
                alt="Screenshot of clicking the “Delete” button on a confirmation popup dialog"
              />
              <figcaption>
                83: Screenshot of clicking the “Delete” button on a confirmation
                popup dialog
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/84.png"
                alt="Screenshot of going through all the deletion steps for the next function"
              />
              <figcaption>
                84: Screenshot of going through all the deletion steps for the
                next function
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/85.png"
                alt="Screenshot of going through all the deletion steps for the next function"
              />
              <figcaption>
                85: Screenshot of going through all the deletion steps for the
                next function
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/86.png"
                alt="Screenshot of going through all the deletion steps for the next function"
              />
              <figcaption>
                86: Screenshot of going through all the deletion steps for the
                next function
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/87.png"
                alt="Screenshot of opening the “Services” dropdown"
              />
              <figcaption>
                87: Screenshot of opening the “Services” dropdown
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/88.png"
                alt="Screenshot of the “Services” dropdown menu and clicking the “IAM” hyperlink"
              />
              <figcaption>
                88: Screenshot of the “Services” dropdown menu and clicking the
                “IAM” hyperlink
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/89.png"
                alt="Screenshot of clicking the “Roles” hyperlink on the sidebar"
              />
              <figcaption>
                89: Screenshot of clicking the “Roles” hyperlink on the sidebar
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/90.png"
                alt="Screenshot of selecting the roles to be deleted"
              />
              <figcaption>
                90: Screenshot of selecting the roles to be deleted
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/91.png"
                alt="Screenshot of clicking the “Delete role” button"
              />
              <figcaption>
                91: Screenshot of clicking the “Delete role” button
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/92.png"
                alt="Screenshot of clicking the “Yes, delete” button on a confirmation popup dialog"
              />
              <figcaption>
                92: Screenshot of clicking the “Yes, delete” button on a
                confirmation popup dialog
              </figcaption>
            </figure>
            <figure>
              <img
                src="assets/images/console-slideshow/93.png"
                alt="Screenshot of all remaining IAM roles"
              />
              <figcaption>93: Screenshot of all remaining IAM roles</figcaption>
            </figure>
          </div>
        </figure>

        <p>To recap those 93 slides, here are the 15 major steps to deploy:</p>

        <ol>
          <li>Navigate to the Step Functions console</li>
          <li>Select “State Machine”</li>
          <li>Select “Create State Machine”</li>
          <li>Provide ASL definition</li>
          <li>Conditionally modify</li>
          <li>Navigate to Lambda console</li>
          <li>Configure Lambda (runtime, name, permissions, etc.)</li>
          <li>Define Lambda</li>
          <li>Save Lambda</li>
          <li>Copy Amazon Resource Name (ARN)</li>
          <li>Paste valid ARN into state machine definition</li>
          <li>Repeat steps 6-11 for each Lambda</li>
          <li>Save state machine definition</li>
          <li>Navigate to and fill out name, tags, logs, etc.</li>
          <li>Deploy state machine</li>
        </ol>

        <p>And here are the 9 major steps to tear down:</p>

        <ol>
          <li>Navigate to the Step Functions console</li>
          <li>Click the “Delete” button, confirming any popup</li>
          <li>Navigate to Lambda console</li>
          <li>Select a Lambda</li>
          <li>Click the “Delete” button from the “Actions” drop-down menu</li>
          <li>Confirm deletion</li>
          <li>Repeat steps 4-6 for each Lambda</li>
          <li>Navigate to the IAM console</li>
          <li>Navigate to “roles”, select the roles, then click the “Delete role” button, confirming any popup</li>
        </ol>

        <p>Now, the same process but using Maestro:</p>

        <figure>
          <video controls>
            <source src="assets/videos/using-maestro.mp4" type="video/mp4" />
            A video of using maestro to deploy a workflow.
          </video>
          <aside>
            <small>
              Note that it is not necessary to navigate through the console when
              using Maestro. We did so in this video just to demonstrate that
              the resources were deployed to AWS and worked as expected.
            </small>
          </aside>
          <figcaption>Using Maestro</figcaption>
        </figure>

        <p>To recap that video, here are the 3 major steps to deploy:</p>

        <ol>
          <li>Open your terminal, execute <code class="command language-plaintext">maestro&nbsp;new</code></li>
          <li>Edit your workflow</li>
          <li>Execute <code class="command language-plaintext">maestro&nbsp;deploy</code></li>
        </ol>

        <p>And here is the 1 major step to tear down:</p>

        <ol>
          <li>Execute <code class="command language-plaintext">maestro&nbsp;teardown</code></li>
        </ol>

        <p>
          The difference between using the AWS Management Console vs Maestro is quite a
          stark one. What took 24 steps across all resources to create the
          workflow (not to mention deleting) takes just 3 with Maestro, all in
          the comfort of your own terminal. And when considering the 2-3 min
          deployment time of AWS SAM, the 3-step, 3-second deployment time and
          1-step, 2-second teardown time of Maestro is unbeatable and wildly
          refreshing to work with.
        </p>

        <p>
          In addition to its lightning-fast deploys and teardowns, Maestro has
          robust manual (man) and inline help (discussed in the table below)
        </p>

        <h3>7.1 Commands</h3>

        <p>Out of the box, Maestro comes with 6 simple commands:</p>

        <table id="commands-table">
          <thead>
            <tr>
              <th>Command</th>
              <th>Description</th>
            </tr>
          </thead>

          <tbody>
            <tr>
              <td>
                <code class="command language-plaintext">
                  <pre>maestro new</pre>
                </code>
              </td>

              <td>
                <p>
                  This command creates a new Maestro project with the given
                  project name. When
                  <code class="command language-plaintext">maestro new</code> is
                  executed, the user is prompted with a list of all the
                  templates to base their new project off of.
                </p>

                <p>
                  If the user simply presses <code>&lt;return&gt;</code>at the
                  prompt or enters invalid input, the new project is created
                  without the influence of a template.
                </p>
              </td>
            </tr>

            <tr>
              <td>
                <code class="command language-plaintext">
                  <pre>maestro deploy</pre>
                </code>
              </td>

              <td>
                <p>
                  This command must be executed at the root of your Maestro
                  project. It will deploy both the state machine as defined in
                  <code>definition.asl.json</code> and all lambda functions
                  defined in the <code>lambdas/</code> directory. If you do not
                  have the necessary Maestro IAM roles, running this command
                  will automatically create them for you as part of the
                  deployment.
                </p>

                <p>
                  Typical deployment time is a lightning-fast
                  <em>3 seconds</em>.
                </p>
              </td>
            </tr>

            <tr>
              <td>
                <code class="command language-plaintext">
                  <pre>maestro teardown</pre>
                </code>
              </td>

              <td>
                <p>
                  Executing this command with your working directory being the
                  root of some Maestro project will tear down the associated
                  resources from AWS, which are as follows:
                </p>

                <ul>
                  <li>
                    All AWS Lambdas uploaded from the project-local
                    <code>lambdas/</code> directory.
                  </li>
                  <li>
                    The AWS Step Functions state machine created from the
                    project-local <code>definition.asl.json</code> definition
                    file.
                  </li>
                  <li>Any AWS IAM roles specified via an optional flag.</li>
                </ul>
              </td>
            </tr>

            <tr>
              <td>
                <code class="command language-plaintext">
                  <pre>maestro help</pre>
                </code>
              </td>

              <td>
                <p>
                  Display help information about Maestro or a Maestro command.
                </p>
              </td>
            </tr>

            <tr>
              <td>
                <code class="command language-plaintext">
                  <pre>maestro config</pre>
                </code>
              </td>

              <td>
                <p>
                  The
                  <code class="command language-plaintext">maestro config</code
                  >command should be the first command run after installing
                  Maestro. Any Maestro deployment or teardown depends on the
                  account information configured by this command.
                </p>
              </td>
            </tr>

            <tr>
              <td>
                <code class="command language-plaintext">
                  <pre>maestro get-templates</pre>
                </code>
              </td>

              <td>
                <p>
                  Fetches the Maestro default templates from git and installs
                  them on the user’s local machine.
                </p>
              </td>
            </tr>
          </tbody>
        </table>

        <h3>7.2 Challenges</h3>

        <p>
          While we were building the Maestro framework, we came across a few
          challenges along the way, which we will now discuss.
        </p>

        <h4>7.2.1 AWS IAM</h4>

        <p>
          One source of difficulty was dealing with AWS IAM [<a
            href="#reference_17"
            class="reference"
            >17</a
          >]. IAM is the AWS service that manages the creation of, deletion of,
          and management of roles, permissions, and policies that dictate what
          specific AWS services are allowed to do. Authorization is often a
          challenge in most programming environments, and AWS is no exception.
        </p>

        <p>
          The first challenge that we, the Maestro team, ran into when working
          with AWS IAM was determining what set of permissions and policies must
          be provided to allow each component to execute properly. One would
          imagine that clear documentation regarding which permissions and
          policies allow execution of a given task would be easy to find, but
          that was not our experience.
        </p>

        <p>
          To determine which basic capabilities the components in a standard
          Lambda-centric workflow required, we manually created some mock
          components and observed which policies AWS attached by default. This
          gave us a starting point for determining exactly which policies the
          Lambdas and Step Functions that Maestro deploys needs.
        </p>

        <p>
          The second challenge regarding IAM that we ran into was the
          propagation of roles. While Maestro creates roles before it attempts
          to create the Lambdas and Step Functions state machines that depend on
          those roles, we still ran into problems regarding the roles’
          availability. This is because, in order to attach a role to an AWS
          resource, the role must first propagate to every AWS data center,
          which can take upwards of 15 seconds. If one were to try to attach a
          role to a Lambda before the role had a chance to fully propagate, the
          role would not attach and would instead throw a cryptic error
          message. Unfortunately, there is no simple way to determine whether a
          role is ready for attachment or not. As of the time of this writing
          (Fall 2020), the best way to determine that is to try to attach the
          role to a resource (such as a Lambda) and see if the cryptic error
          message is thrown back.
        </p>

        <p>
          Therefore, to create Lambdas and state machines with associated roles,
          we resolved to implement retry when attaching a role to a resource.
          Built-in retry does not exist in the AWS SDK, so we created our own
          robust and general-purpose retry function that handles the number of
          attempts and the backoff rate between subsequent attempts. The retry,
          in combination with an initial sleep period and tuned backoff rate,
          solved this challenge and made Maestro even more robust than before.
        </p>

        <h4>7.2.2 Asynchronicity</h4>

        <p>
          Creating multiple AWS resources that depend on one another in
          deployment touches on an overarching challenge that would need to be
          reconciled in developing Maestro: asynchronicity. Maestro offers quick
          deployment thanks to concurrent creation and deployment of resources
          which requires navigating numerous issues related to synchronicity.
        </p>

        <p>
          A helpful pattern that allowed us to work with asynchronous functions
          and Promises was the ‘async/await’ pattern. This allowed certain
          actions to be treated synchronously in an asynchronous context.
          However, the Maestro philosophy was not to completely remove Promise
          chains by dogmatically applying the ‘async/await’ pattern everywhere
          possible. Overuse of the pattern can cause code to be slow by
          essentially making every step synchronous [<a
            href="#reference_18"
            class="reference"
            >18</a
          >]. To achieve relevant concurrency in creating resources, a mixture
          of ‘Promise chains’, ‘async/await’, and
          <code class="command language-plaintext">Promise.all</code> was
          implemented. The result is a lightning-fast framework.
        </p>

        <h4>7.2.3 Domain</h4>

        <p>
          Serverless orchestration is a very niche topic. Although AWS Lambda is
          a popular service, orchestration is often done company-by-company
          without adhering to a common set of shared best practices. Navigating
          common approaches required extensive, in-depth inquiry. Further, AWS
          Step Functions offers many benefits but is not broadly used; as a
          result, few frameworks or solutions exist to provide insight into
          development. Therefore, we had to be quite innovative to provide a
          framework in this space.
        </p>

        <h3>7.3 Future Work</h3>

        <p>
          As with most endeavors, not all that was desired could be accomplished
          from the outset. Here are a few aspirations that are left for future
          work.
        </p>

        <h4>7.3.1 ASL Wrapper</h4>

        <p>
          Ultimately, a framework that works with ASL could be benefited by
          abstracting away the awkward language. As was previously described,
          the objective of Maestro is to facilitate working with ASL through
          templates. However, no set of templates can be comprehensive, and any
          developer working extensively with Step Functions will eventually
          require writing ASL. Having an ASL ‘wrapper’ to imperatively write ASL
          in native JavaScript would be helpful.
        </p>

        <h4>7.3.2 Logging</h4>

        <p>
          Another possible future addition would be integration with the host
          logging system. More robust logging is helpful in the event something
          goes wrong with the deployment of an individual component or an entire
          workflow.
        </p>

        <h4>7.3.3 Versioning</h4>

        <p>
          Because the premise of Maestro is to allow rapid iteration on
          workflows, versioning comes into view. Much consideration must go into
          determining the point at which a workflow is ready for production, and
          due to innumerable circumstances, a team may resolve to look back at
          some previous version of their application. Ideally, a version of the
          workflow would be persisted and easily accessible every time a
          workflow was deployed.
        </p>

        <h4>7.3.4 Redeploy Command</h4>

        <p>
          Which brings to mind another consideration left for the future: a
          <code class="command language-plaintext">maestro redeploy</code>
          command. It would be helpful, especially for complex workflows, to
          intelligently re-deploy only elements of the workflow that have
          changed since the last version. If versioning were clearly outlined,
          then re-deploying could look back at a snapshot of the workflow to
          determine what changed and then re-deploy accordingly. This would help
          preserve artifacts in AWS that provide auditability of long-standing
          components as well as reduce the load on the network.
        </p>

        <h4>7.3.5 Multiple AWS Services</h4>

        <p>
          The focus of Maestro is AWS Lambdas, but that doesn’t have to be the
          case. While much can be achieved, and often is, strictly using
          Lambdas, other services offer a broader range of development
          possibilities. Integrating further AWS services into Maestro would
          amplify its potential.
        </p>

        <h4>7.3.6. Per-Project Configuration</h4>

        <p>
          Currently, Maestro only uses a single global configuration file. It
          would be beneficial to have a unique config file for each project
          allowing deployment in various regions and even to different AWS
          accounts. On a similar note, a developer may wish to use different
          Node.js&reg; runtimes, so support for various versions could be added.
        </p>

        <section id="references">
          <h2>8. References</h2>

          <ol>
            <li id="reference_1">
              <a
                target="_blank"
                href="https://research.chalmers.se/publication/508147/file/508147_Fulltext.pdf"
                >A mixed-method empirical study of Function-as-a-Service
                software development in industrial practice</a
              >
            </li>
            <li id="reference_2">
              <a target="_blank" href="https://www.serverless.com/aws-lambda"
                >AWS Lambda - The Ultimate Guide</a
              >
            </li>

            <li id="reference_3">
              <a
                target="_blank"
                href="https://www.researchgate.net/publication/340121613_Patterns_for_Serverless_Functions_Function-as-a-Service_A_Multivocal_Literature_Review"
                >Patterns for Serverless Functions</a
              >
            </li>
            <li id="reference_4">
              <a target="_blank" href="https://www.serverlesschats.com/16/"
                >Serverless Workflows using Step Functions</a
              >
            </li>
            <li id="reference_5">
              <a
                target="_blank"
                href="https://docs.aws.amazon.com/step-functions/latest/dg/welcome.html"
                >What Is AWS Step Functions?</a
              >
            </li>
            <li id="reference_6">
              <a
                target="_blank"
                href="https://www.serverless.com/aws-step-functions#drawbacks"
                >AWS Step Functions - The Ultimate Guide</a
              >
            </li>
            <li id="reference_7">
              <a
                target="_blank"
                href="https://acloud.guru/series/serverlessconf-nyc-2019/view/yaml-better?_hsenc=p2ANqtz-8NTIqitxWIiUw-zP8PduvB33SIKeFTL96OW8aFES-aovT2WN3ULwZm_cXSRpmntdO4cF6Z"
                >YAML Is Better than Your Favorite Language: Fightin’ words
                about Infrastructure as code | Ben Kehoe</a
              >
            </li>
            <li id="reference_8">
              <a target="_blank" href="https://aws.amazon.com/console/"
                >AWS Management Console</a
              >
            </li>
            <li id="reference_9">
              <a target="_blank" href="https://aws.amazon.com/cloudformation/"
                >AWS Cloud Formation</a
              >
            </li>
            <li id="reference_10">
              <a
                target="_blank"
                href="https://aws.amazon.com/getting-started/tools-sdks/"
                >Start building with SDKs and tools</a
              >
            </li>
            <li id="reference_11">
              <a target="_blank" href="https://www.serverless.com/"
                >Serverless Framework</a
              >
            </li>
            <li id="reference_12">
              <a
                target="_blank"
                href="https://www.serverless.com/learn/comparisons/"
                >Serverless Framework Comparisons</a
              >
            </li>
            <li id="reference_13">
              <a
                target="_blank"
                href="https://github.com/serverless-operations/serverless-step-functions#how-to-split-up-state-machines-into-files"
                >Step Functions plugin for Serverless Framework</a
              >
            </li>
            <li id="reference_14">
              <a target="_blank" href="https://aws.amazon.com/serverless/sam/"
                >AWS Serverless Application Model</a
              >
            </li>
            <li id="reference_15">
              <a
                target="_blank"
                href="https://aws.amazon.com/about-aws/whats-new/2020/05/aws-sam-adds-support-for-aws-step-functions/"
                >AWS SAM adds support for Step Functions</a
              >
            </li>
            <li id="reference_16">
              <a target="_blank" href="https://github.com/coinbase/step"
                >Step</a
              >
            </li>
            <li id="reference_17">
              <a
                target="_blank"
                href="https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction.html"
                >What is IAM?</a
              >
            </li>
            <li id="reference_18">
              <a
                target="_blank"
                href="https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Asynchronous/Async_await"
                >Async / await</a
              >
            </li>
            <li>
              <a target="_blank" href="https://arxiv.org/pdf/1807.11248.pdf"
                >Comparison of FaaS Orchestration Systems</a
              >
            </li>
            <li>
              <a target="_blank" href="https://www.ibm.com/cloud/learn/faas"
                >FaaS</a
              >
            </li>
            <li>
              <a
                target="_blank"
                href="https://medium.com/serverless-transformation/serverless-event-scheduling-using-aws-step-functions-b4f24997c8e2"
                >Serverless Event Scheduling — Using AWS Step Functions</a
              >
            </li>
            <li>
              <a
                target="_blank"
                href="https://www.cloudflare.com/learning/serverless/glossary/serverless-vs-paas/"
                >How are serverless computing and Platform-as-a-Service
                different?</a
              >
            </li>
            <li>
              <a
                target="_blank"
                href="https://aws.amazon.com/solutions/case-studies/the-guardian/"
                >Guardian News &amp; Media Automates Subscription Fulfillment
                Using AWS Step Functions</a
              >
            </li>
            <li>
              <a
                target="_blank"
                href="https://medium.com/@scott_triglia/building-self-healing-observable-systems-with-aws-step-functions-8fe5b402ef7e"
                >Building self-healing, observable systems with AWS Step
                Functions</a
              >
            </li>
            <li>
              <a
                target="_blank"
                href="https://medium.com/weareservian/aws-step-functions-the-power-of-simplicity-10e8395af4f3"
                >AWS Step Functions - The Power of Simplicity</a
              >
            </li>
            <li>
              <a
                target="_blank"
                href="https://engineeringblog.yelp.com/2017/11/breaking-down-the-monolith-with-aws-step-functions.html"
                >Breaking down the monolith with AWS Step Functions</a
              >
            </li>
            <li>
              <a target="_blank" href="https://github.com/sosw/sosw">SOSW</a>
            </li>
            <li>
              <a
                target="_blank"
                href="https://medium.com/a-tale-of-2-from-data-to-information/serverless-smart-radio-1cabcab8de30"
                >Serverless Smart Radio</a
              >
            </li>
            <li>
              <a
                target="_blank"
                href="https://hackernoon.com/what-is-serverless-architecture-what-are-its-pros-and-cons-cc4b804022e9"
                >What is Serverless Architecture? What are its Pros and Cons?</a
              >
            </li>
            <li>
              <a target="_blank" href="https://aws.amazon.com/what-is-aws/"
                >What is AWS?</a
              >
            </li>
            <li>
              <a
                href="https://www.youtube.com/watch?v=bEB0zDHXXG4&feature=youtu.be"
                target="_blank"
                >Youtube tutorial for deploying with Serverless Framework</a
              >
            </li>
            <li>
              <a href="https://states-language.net/spec.html"
                >Amazon States Language Specification</a
              >
            </li>
          </ol>
        </section>
      </section>
    </main>
    <section id="our-team">
      <img
        src="assets/images/logos/maestro/mark-on-light.png"
        alt="Maestro logo"
      />
      <h1>Our Team</h1>
      <p>
        We are looking for opportunities. If you liked what you saw and want to
        talk more, please reach out!
      </p>
      <ul>
        <li class="individual">
          <a href="https://t-monius.github.io/" target="_blank"
            ><img
              src="assets/images/team/torrel_moseley.jpg"
              alt="Torrel Moseley"
          /></a>
          <h3>Torrel Moseley</h3>
          <p>NYC &amp; Denver</p>
          <ul class="social-icons">
            <li>
              <a href="mailto:trrl.mo&commat;hotmail.com" target="_blank"
                ><img src="assets/images/icons/email_icon.png" alt="email"
              /></a>
            </li>
            <li>
              <a href="https://t-monius.github.io/" target="_blank"
                ><img src="assets/images/icons/website_icon.png" alt="website"
              /></a>
            </li>
            <li>
              <a
                href="https://www.linkedin.com/in/torrelmoseley/"
                target="_blank"
                ><img
                  src="assets/images/icons/linkedin_icon.png"
                  alt="LinkedIn Icon"
              /></a>
            </li>
          </ul>
        </li>
        <li class="individual">
          <a href="https://zklamm.github.io/" target="_blank">
            <img src="assets/images/team/zac_klammer.jpg" alt="Zac Klammer" />
          </a>
          <h3>Zac Klammer</h3>
          <p>Corpus Christi, TX</p>
          <ul class="social-icons">
            <li>
              <a href="mailto:zklamm&commat;gmail.com" target="_blank"
                ><img src="assets/images/icons/email_icon.png" alt="email"
              /></a>
            </li>
            <li>
              <a href="https://zklamm.github.io/" target="_blank"
                ><img src="assets/images/icons/website_icon.png" alt="website"
              /></a>
            </li>
            <li>
              <a href="https://www.linkedin.com/in/zac-klammer/" target="_blank"
                ><img
                  src="assets/images/icons/linkedin_icon.png"
                  alt="LinkedIn Icon"
              /></a>
            </li>
          </ul>
        </li>
        <li class="individual">
          <a href="https://johnisom.dev/" target="_blank">
            <img
              src="assets/images/team/john_isom.jpg"
              alt="Picture of John Isom"
          /></a>
          <h3>John Isom</h3>

          <p>Salt Lake City, UT</p>
          <ul class="social-icons">
            <li>
              <a href="mailto:john&commat;johnisom.dev" target="_blank"
                ><img src="assets/images/icons/email_icon.png" alt="email"
              /></a>
            </li>
            <li>
              <a href="https://johnisom.dev/" target="_blank"
                ><img src="assets/images/icons/website_icon.png" alt="website"
              /></a>
            </li>
            <li>
              <a href="https://linkedin.com/in/john-isom/" target="_blank"
                ><img
                  src="assets/images/icons/linkedin_icon.png"
                  alt="LinkedIn Icon"
              /></a>
            </li>
          </ul>
        </li>
      </ul>
    </section>
  </body>
</html>