DEV Community: Charisse C. Lorejo

Build an Automated AWS CI/CD Pipeline with CDK

Charisse C. Lorejo — Sat, 30 May 2026 16:05:02 +0000

This article will talk about how to automate the deployment of a modern React website using Amazon Web Services (AWS). Instead of manually deploying files, you will build an automated Continuous Integration and Continuous Deployment (CI/CD) pipeline. By the end of this session, every time you push code to GitHub, AWS will automatically test, build, and deploy your application to the internet.

The Concepts: DevOps and CI/CD

Before we build the infrastructure, let's look at why we need it.

A Brief History: The Problem of Silos

Before DevOps, a software development organization was typically split into two completely separate teams:

The Development Team: Designs the system, plans how to build it, and writes the actual code.
The Operations Team: Takes the code, tests it, checks for bugs, and manages the live servers. They send feedback back to the developers when things break.

The Problem: Because these teams were siloed, deadlocks occurred. When developers were writing code, operations sat idle. When operations was testing and deploying, developers had to wait for feedback. It created massive bottlenecks and endless "waiting for the other team" scenarios.

The Solution: DevOps

DevOps is a philosophy that breaks down the barrier between Development and Operations, transforming the software development lifecycle into a continuous, collaborative process.

It forms a continuous loop:

Plan & Code: The team plans the feature and writes the code, storing it in a version control system (like Git) so changes can be tracked or reverted.
Build & Test: The code is compiled into an executable format and automatically tested for bugs. If it passes, it's ready.
Deploy & Monitor: The code is deployed to the working environment (often using containers). The system is actively monitored for errors.
Feedback: Any issues or user behavior metrics are sent right back to the planning phase, and the cycle continues.

Automating the Cycle with CI/CD

DevOps is a great culture, but how do we make it fast and automatic? That is where CI/CD comes in.

Continuous Integration (CI): Developers commit code to a shared repository frequently. Every time they push a small commit, a CI server automatically builds the code and tells them if it was a success or failure. This avoids massive merge conflicts.
Continuous Deployment (CD): Once the code passes the CI checks, it is automatically deployed to the live environment without human intervention.

Mapping CI/CD to Our AWS Pipeline:
In this workshop, we will map this exact lifecycle to an automated AWS CodePipeline:

Source Stage: GitHub (Version control and storing our code).
Build & Test Stage: AWS CodeBuild (Our CI server that installs dependencies and builds the app).
Deploy Stage: AWS CodeDeploy / Amazon S3 / CloudFront (Where our live application lives and updates automatically).

Prerequisites

Before beginning the workshop, ensure you have the following ready:

A registered GitHub account
An active AWS Account
Node.js installed on your local machine (version 18 or higher recommended)
A code editor, such as Visual Studio Code

Step 1: Fork and Clone the Repository

To build a pipeline, you need your own copy of the source code so that AWS can detect your specific changes.

Navigate to the workshop repository on GitHub:
chalorejo / devops-workshop-game
DevOps Workshop Game

The DevOps Workshop Game is a full-stack, cloud-native Rock Paper Scissors application designed to demonstrate infrastructure as code (IaC) and CI/CD pipelines. This project features a React/Vite frontend and an AWS CDK-powered backend that fully automates the provisioning of S3 buckets, CloudFront CDN, and a CodePipeline for continuous deployment.

Requirements & Installation

To deploy and work with this project, you will need the following tools:
- Node.js (v20 or higher recommended)
- AWS CLI (configured with your AWS account credentials)
- AWS CDK (npm install -g aws-cdk)
- Git
To set up the project locally:
1. Clone the repository
  
  git clone <repository-url> cd devops-workshop-game
2. Install the AWS CDK dependencies:
  
  npm install
3. Update bin/devops-workshop-game.js with your AWS Account ID and preferred Region.
4. Update the GitHub Source Action in lib/devops-workshop-game-stack.js with your GitHub username and configure your GitHub token in AWS Secrets Manager as workshop/github.
Usage Guide

To synthesize…
View on GitHub
Click the Fork button in the top right corner to create a copy of this repository in your personal GitHub account.
Open your local terminal and clone your newly forked repository by running the following command (replace YOUR_USERNAME with your actual GitHub username):

git clone https://github.com/YOUR_USERNAME/devops-workshop-game.git

Change your directory into the cloned folder:

cd devops-workshop-game

Step 2: Authenticate with AWS

Your local terminal requires explicit permission to interact with your AWS account and provision infrastructure.

Part A: Create an IAM User and Generate Access Keys

Since deploying infrastructure with CDK requires administrative permissions, you will first create a dedicated IAM user.

Log in to the AWS Management Console.
In the top search bar, search for IAM (Identity and Access Management) and select it.

On the left-hand sidebar, click on Users, then click the Create user button.

Enter a user name (e.g., workshop-admin) and click Next.
On the permissions page, select Attach policies directly.
In the permissions policies search bar, type AdministratorAccess. Check the box next to it and click Next.

Review the details and click Create user.
Back on the Users list, click on your newly created user (workshop-admin).
Navigate to the Security credentials tab.

Scroll down to the Access keys section and click Create access key.
Select Command Line Interface (CLI) as the use case, acknowledge the warning, and click Next.

Click Create access key. Leave this window open, as it displays your Secret Access Key which will never be shown again.

Part B: Configure the CLI

Open your terminal and type:

aws configure

Enter the details exactly as prompted:
AWS Access Key ID: (Copy and paste from the AWS webpage)
AWS Secret Access Key: (Copy and paste from the AWS webpage)
Default region name: ap-southeast-1
Default output format: json

Step 3: Generate a GitHub Personal Access Token

AWS CodePipeline requires authorization to securely pull your source code from GitHub whenever a new commit is detected.

Go to GitHub, click your profile picture in the top right, and select Settings.
Scroll down the left sidebar and click Developer settings.
Click Personal access tokens followed by Tokens (classic).

Click Generate new token (classic).

Name the token descriptively, such as "AWS Workshop Pipeline".
Under Select scopes, check the box next to repo (This grants full control of private and public repositories).

Scroll to the bottom and click Generate token.

Copy the token immediately. It will start with ghp_. Store it temporarily in a secure location.

Step 4: Store Your Token Securely in AWS

Hardcoding security tokens in source code is a major security risk. You will use AWS Secrets Manager to store the token securely.

In your terminal, run the following command. Replace <YOUR_TOKEN> with the exact token you copied from GitHub:

aws secretsmanager create-secret --name workshop/github --secret-string '{"token":"<YOUR_TOKEN>"}' --region ap-southeast-1

Upon success, the terminal will output a JSON block confirming the secret's creation.

Step 5: Install and Set Up AWS CDK

The AWS Cloud Development Kit (CDK) is a framework that allows you to define cloud infrastructure using familiar programming languages like JavaScript.

Install the CDK globally on your machine using the Node Package Manager:

npm install -g aws-cdk

Verify that the installation was successful by checking the version:

cdk --version

Install the specific project dependencies required for this workshop:

npm install

Step 6: Understanding the Infrastructure Code

Before connecting the pipeline, open lib/devops-workshop-game-stack.js. This file is the core of our "Infrastructure as Code" (IaC) setup. Instead of clicking through the AWS console, this JavaScript code defines exactly what cloud resources AWS needs to build for your app.

Here is a breakdown of what the code is doing:

The Website Hosting Bucket: The websiteBucket object creates an Amazon S3 bucket configured specifically for static web hosting. Notice the blockPublicAccess section—we explicitly turn off the default security blocks so anyone on the internet can see your live game.

The Global Content Delivery Network (CDN): To ensure game assets (like images) load instantly worldwide, the code provisions an AssetsBucket and pairs it with an AWS CloudFront distribution (AssetsCDN). It even uses BucketDeployment to automatically copy local files from ./frontend/src/assets directly into this bucket.
The Automated Builder (CodeBuild): The buildProject definition acts as our temporary build server. It spins up a Linux container with Node.js 20, passes in the new CloudFront URL as an environment variable (VITE_CDN_URL), and runs npm run build to compile our Vite application.

It also automatically provisions IAM permissions to send build logs to Amazon CloudWatch.

The Pipeline Orchestrator (CodePipeline): Finally, the WorkshopPipeline ties everything together into a three-stage workflow:
- Source: Listens to your GitHub main branch and pulls code securely using the Secrets Manager token.
- Build: Hands the fresh code to the CodeBuild project.
- Deploy: Takes the finalized dist folder from the build output and places it in your public S3 Website Bucket.

Step 7: Connect Your Code to the Pipeline and Configure Environment

You must configure the infrastructure code to target your specific GitHub fork rather than the original repository, and set up your specific AWS account environment.

Part A: Update the Pipeline Stack

Open the project folder in your code editor.
Navigate to the file located at lib/devops-workshop-game-stack.js.
Locate the GitHubSourceAction configuration block.
Modify the owner field and output block to ensure it looks exactly like this:

actions: [
  new codepipeline_actions.GitHubSourceAction({
    actionName: 'GitHub_Source',
    owner: '<ENTER YOUR GITHUB USERNAME>',
    repo: 'devops-workshop-game',
    branch: 'main',
    // You will create a GitHub token and store it in AWS Secrets Manager
    oauthToken: SecretValue.secretsManager('workshop/github', { jsonField: 'token' }),
    output: sourceOutput,
  }),
],

Save the file.

Part B: Configure Your AWS Environment

Navigate to the application entry point file, typically located at bin/devops-workshop-game.js.
Locate the environment (env) configuration block.
Update the account property to use your specific environment setup:

env: {
  account: '<ENTER ACCOUNT NUMBER>', // Your AWS Account ID from the ARN
  region: 'ap-southeast-1'  // The region where you created the secret
},

Save the file.

Step 8: Bootstrap and Deploy the Infrastructure

It is now time to compile your code into an AWS CloudFormation template and deploy it to the cloud.

Bootstrap your AWS environment. Bootstrapping provisions initial resources (like Amazon S3 buckets and IAM roles) that the CDK needs to perform deployments. Replace <YOUR_AWS_ACCOUNT_ID> with your 12-digit AWS account number (found by clicking your name in the top right of the AWS console):

cdk bootstrap aws://<YOUR_AWS_ACCOUNT_ID>/ap-southeast-1

Once bootstrapping is complete, deploy the pipeline:

cdk deploy

The CLI will present a summary of security and IAM changes. Type y and press Enter to approve them.
The initial deployment and build process will take several minutes to complete.

Step 9: Find Your Live App & Test the Workflow

Your pipeline is now active, and your application is hosted on an S3 bucket. You will now find your live URL and test the Continuous Deployment mechanism.

Part A: Find Your Live Website URL

You can access your website link using either the terminal or the AWS console.

Option 1: Via the AWS CLI (Terminal)

List your S3 buckets to find the exact, unique name of your generated bucket:

aws s3 ls

Look for a bucket name starting with devopsworkshopgamestack-websitebucket.

Your live website URL follows this standard S3 format (replace <YOUR_BUCKET_NAME> with the exact name you found above): http://<YOUR_BUCKET_NAME>.s3-website.ap-southeast-1.amazonaws.com (Note: Make sure it is http:// and not https://)

Option 2: Via the AWS Console

Open the AWS Console, navigate to the S3 service, and click on your new bucket.
Select the Properties tab, scroll to the very bottom, and click the link under Static website hosting.

Part B: Test the Automation

Return to your code editor and open frontend/src/App.jsx.
Make a visible change to the application, such as modifying the title text or altering a Tailwind CSS color class.
Save the file, commit the change, and push it to your GitHub repository:

git add .
git commit -m "Updated application title for deployment test"
git push origin main

Navigate to the AWS CodePipeline dashboard in your web browser. You will observe the pipeline automatically trigger, process the new code, rebuild the application, and update the live S3 website without any manual intervention.

Step 10: Clean Up Resources (Crucial)

Warning: To ensure you do not incur unwanted charges on your AWS account after the workshop, you must tear down the infrastructure you built.

1. Destroy the CDK Stack

This command will delete the S3 bucket, CodeBuild project, and CodePipeline. Run this in your terminal from the root of your project:

cdk destroy

Type y and press Enter when asked to confirm the deletion.

2. Delete the Secret

The AWS CDK command does not delete secrets you created manually. Delete your GitHub token from AWS Secrets Manager by running:

aws secretsmanager delete-secret --secret-id workshop/github --force-delete-without-recovery --region ap-southeast-1

3. Revoke the GitHub Token

Finally, practice good security hygiene by deleting the token from GitHub so it can never be used again.

Go to GitHub > Settings > Developer settings > Personal access tokens > Tokens (classic).
Find "AWS Workshop Pipeline" and click the Delete button next to it.

fdxs

Charisse C. Lorejo — Tue, 09 Dec 2025 20:35:02 +0000

Understand the Global Infrastructure of Amazon Web Services

Charisse C. Lorejo — Wed, 12 Nov 2025 02:36:37 +0000

As a beginner of AWS, one of the first things you do is to pick a Region. But why does this matter? What does AWS Global Infrastructure mean?

It may seem little or even insignificant at first but AWS Global Infrastructure is the backbone to all AWS services. It is design to deliver high-speed and high-performance cloud services to all customers worldwide.

We will discuss each major components of the AWS Global Infrastructure namely:

Regions,
Availability Zones,
Data Centers, and
Edge Locations

What are the parts of the AWS Global Infrastructure?

AWS Regions

Image Source

As of 2025, AWS consists of about 33 geographic Regions across the global and even more coming in the future.
Each Region is independent of the others. This separation allows you to choose where your data is stored and where your applications run.
A Region is a separate geographic area—like Singapore, Tokyo, Frankfurt, or Ohio.

Why is it important to choose the right Region?

To reduce latency
To meet compliance or data-residency requirements
To keep your services close to your users

Availability Zones (AZs)

Image Source

Now that we have an idea about region, we now have Availability Zones. Inside every region, there are multiple AZs, typically three(3) or more. An Availability Zone is made up of one or more physically separate data centers within the same Region.

Key Point:

Availability Zones are close enough to provide low latency, but far enough apart to prevent failures from affecting the whole Region.
If one AZ goes down due to power, network, or natural disaster issues, the others remain available. This is why AWS is known for high reliability.

Data Centers

Data centers are the physical buildings that contain:

servers

networking equipment

power and cooling systems

AWS data centers house the actual computing hardware where your cloud resources run.
Each AZ contains multiple data centers to ensure redundancy. When we say your "resources are in the cloud," they really live inside these secure facilities.

Visual Representation

Image Source
This is what the global infrastructure looks like. A region contains three or more AZs, and AZs have data centers that runs the cloud.

Edge Locations

Not every country has an AWS Region, but many countries, including the Philippines, have Edge Locations.
Edge locations are used by services like:

Amazon CloudFront (CDN)

AWS Global Accelerator

Route 53 DNS They act as local access points that cache or route content closer to users.

Why does this matter?

It reduces latency. Instead of your data traveling all the way to the Singapore Region (the closest Region to the Philippines), some content can be served from the Manila edge location, making loading times faster.

Why Do We Need to Understand These Concepts?

Understanding the AWS Global Infrastructure helps you:
1. Choose the Best Region for Your Workloads - Selecting the wrong Region can lead to slow performance or higher costs.

2. Design Highly Available Applications - Using multiple AZs protects your systems from outages.

3. Improve Performance for Global Users - Edge locations help content reach users faster.

4. Meet Compliance and Legal Requirements - Some countries require data to be stored within specific geographic boundaries.
being aware of this can save money.

5. Optimize Cost - Prices vary per Region—being aware of this can save money.

By understanding how Regions, Availability Zones, Data Centers, and Edge Locations work together, users can design cloud solutions that are faster, more secure, and more reliable.

Whether you’re deploying a small web app or managing enterprise-scale systems, knowing how AWS’s infrastructure operates gives you the power to make smarter choices about performance, cost, and resilience in the cloud.

Going Serverless 🤖⚡: How to Launch a Website in less than 15 minutes with AWS Lambda & API Gateway (Beginner-Friendly!)

Charisse C. Lorejo — Thu, 24 Apr 2025 14:49:36 +0000

This article is co-authored with @siosanac

Introducing Amazon Web Services Lambda

What is AWS Lambda? 🤔

AWS Lambda is a serverless computing service made by Amazon Web Services (AWS). It lets you run code without managing the servers~! Lambda automatically scales depending on the number of incoming requests, and you pay only for the compute time used only.

How does it work? 💡

AWS Lambda is a serverless, event-driven compute service that lets you run code in response to events without managing servers. You write single-purpose functions, upload them, and configure triggers.

Why use AWS Lambda?

Now by now you’re still probably not convinced about how lambda can help you 😔. Here are the reasons why many developers chose to use Lamda for building modern cloud-based apps.

No Server Management!

You don’t need to waste your time by maintaining, provisioning, or patching your servers. AWS handles all of the infrastructure’s scaling and availability.

Cost-Efficiency

With this service, you only pay for what you use. That means there will be no charge when you don’t use the utilities. You can be charged for every millisecond of runtime. Lastly, if you need even more resources, Lambda can scale automatically if you want to.

Pricing for Lambda

Lambda has a free tier if you want to experiment with Lambda, it allows you to have 1 million requests per month and this will reset for the other month and then it gives you 400, 000 GB-seconds of computer time per month.

Now if you’re done with experimenting, and you want to get serious the request charge is $0.20 per 1 million requests, Computing charge is $0.0000166667 per GB-second. There’s also an option where you can “rent” a fixed amount of resources it’s called the Ephemeral Storage.

Creating an AWS Account

If you still do not have an Amazon Web Services account, go to this article for a step-by-step guide to start.

Creating a Lambda Function

Now let’s start on creating a Lambda Function! Navigate your AWS Console and search for Lambda in the search bar.

Next, click on the “Create Function” button.

After that, you can name your function anything you want. You can pick any language you prefer in the Runtime and set the Architecture as is, which is x86_64. Scroll down and let’s create our function.

Once you have created your function, this will look something like this.

Scroll down and you can see that there is a Code source. This is where you will put your code snippet and perform operations for your website.

Default Code:

export const handler = async (event) => {
  // TODO implement
  const response = {
    statusCode: 200,
    body: JSON.stringify('Hello from Lambda!'),
  };
  return response;
};

This is still incomplete, for this lambda function to do anything, you must add a trigger first.

Adding a Trigger

Scroll back up and press the add trigger button. For the trigger configuration, select the API Gateway and create a new API. Make sure that it is an HTTP API and configure the security to be open. For now, let the additional settings be on default and add your trigger.

Once you have created your function, this will look something like this.

Once you have added your trigger, scroll down and on the left-hand side, click Trigger, and you should see that you have an API endpoint with a corresponding URL.

If you go to that URL, you might see something like this.

You can see the “Hello from Lambda!” printed out on your page. This is essentially a static website at its simplest level. What is important here is that we have created a trigger for the API gateway so that our Lambda function is exposed to the Internet. Lambda functions can't be called directly via HTTP. API Gateway gives you a RESTful or HTTP endpoint to trigger your Lambda.

Remember:

API Gateway acts like a "bridge"

Static Website: Your frontend, hosted on S3 or other static hosting
API Gateway: The public HTTP endpoint your website can call
Lambda Function: The backend logic, triggered when API Gateway receives a request

Now let’s create our static website with HTML and CSS.

Building the HTML and CSS of the Static Website

Go back to your Lambda Function.

On the bottom left of your browser, click on Code so that you can modify the default code given.

Replace the default code with this code snippet:

export const handler = async (event) => {
  const html = `
    <!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8" />
      <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
      <title>Writers of This Article</title>
      <style>
        body {
          margin: 0;
          font-family: 'Courier New', Courier, monospace;
          background-color: #1e1e1e;
          color: #d4d4d4;
          display: flex;
          flex-direction: column;
          align-items: center;
          padding: 2rem 1rem;
        }
        h1 {
          color: #0f0;
          font-size: 2rem;
          margin-bottom: 2rem;
          border-bottom: 2px solid #3c3c3c;
          padding-bottom: 0.5rem;
          text-align: center;
        }
        .cards-container {
          display: flex;
          flex-wrap: wrap;
          gap: 2rem;
          justify-content: center;
          width: 100%;
          max-width: 1200px;
        }
        .terminal-loader {
          border: 0.1em solid #333;
          background-color: #1a1a1a;
          color: #0f0;
          font-family: "Courier New", Courier, monospace;
          font-size: 1em;
          padding: 1.5em 1em;
          width: 100%;
          max-width: 30em;
          box-shadow: 0 4px 8px rgba(0, 0, 0, 0.2);
          border-radius: 4px;
          position: relative;
          overflow: hidden;
          box-sizing: border-box;
        }
        .terminal-header {
          position: absolute;
          top: 0;
          left: 0;
          right: 0;
          height: 1.5em;
          background-color: #333;
          border-top-left-radius: 4px;
          border-top-right-radius: 4px;
          padding: 0 0.4em;
          box-sizing: border-box;
        }
        .terminal-controls {
          float: right;
        }
        .control {
          display: inline-block;
          width: 0.6em;
          height: 0.6em;
          margin-left: 0.4em;
          border-radius: 50%;
          background-color: #777;
        }
        .control.close { background-color: #e33; }
        .control.minimize { background-color: #ee0; }
        .control.maximize { background-color: #0b0; }
        .terminal-title {
          float: left;
          line-height: 1.5em;
          color: #eee;
        }
        .text {
          display: inline-block;
          white-space: nowrap;
          overflow: hidden;
          border-right: 0.2em solid green;
          animation:
            typeAndDelete 4s steps(11) infinite,
            blinkCursor 0.5s step-end infinite alternate;
          margin-top: 1.5em;
        }
        .text-1 {
          display: block;
          white-space: normal;
          margin-top: 0.5em;
          color: #d4d4d4;
        }
        @keyframes blinkCursor {
          50% {
            border-right-color: transparent;
          }
        }
        @keyframes typeAndDelete {
          0%, 10% { width: 0; }
          45%, 55% { width: 10em; }
          90%, 100% { width: 0; }
        }
        @media (max-width: 768px) {
          .text {
            white-space: normal;
            animation: none;
            border-right: none;
          }
          .terminal-loader {
            width: 100%;
          }
        }
      </style>
    </head>
    <body>
      <h1>Writers of This Article</h1>
      <div class="cards-container">
        <div class="terminal-loader">
          <div class="terminal-header">
            <div class="terminal-title">Writer 1:</div>
            <div class="terminal-controls">
              <div class="control close"></div>
              <div class="control minimize"></div>
              <div class="control maximize"></div>
            </div>
          </div>
          <div class="text">Cerdic Siosana...</div><br/>
          <div class="text-1">Level: 2nd year BSCS</div><br/>
          <div class="text-1">Hobbies: Writing, Coding, Gaming</div><br/>
          <div class="text-1">Motto:<br>
            &nbsp;&nbsp;&nbsp;You lost at the moment<br>
            &nbsp;&nbsp;&nbsp;you decided to quit.</div>
        </div>
        <div class="terminal-loader">
          <div class="terminal-header">
            <div class="terminal-title">Writer 2:</div>
            <div class="terminal-controls">
              <div class="control close"></div>
              <div class="control minimize"></div>
              <div class="control maximize"></div>
            </div>
          </div>
          <div class="text">Charisse Lorejo...</div><br/>
          <div class="text-1">Level: 1st year BSCS</div><br/>
          <div class="text-1">Hobbies: Drawing, Coding, Driving</div><br/>
          <div class="text-1">Motto:<br>
            &nbsp;&nbsp;&nbsp;Yesterday is history,<br>
            &nbsp;&nbsp;&nbsp;tomorrow is a mystery,<br>
            &nbsp;&nbsp;&nbsp;but today is a gift.<br>
            &nbsp;&nbsp;&nbsp;That is why it is called the present.<br>
            &nbsp;&nbsp;&nbsp;- Master Oogway</div>
        </div>
      </div>
    </body>
    </html>
  `;

  return {
    statusCode: 200,
    headers: {
      'Content-Type': 'text/html',
    },
    body: html,
  };
};

After that, deploy the changes. If you go back to the same URL and refresh the website. It should display our new and improved website.

There you go! A step-by-step guide to creating a static website using AWS Lambda!

Conclusion

AWS Lambda is a great beginner tool for you to explore Amazon Web Services. There are a lot more that you can use AWS Lambda aside from creating a static website. Moreover, you can also explore other tools that AWS has to offer, like functions for you to run when a trigger is activated by other AWS services–NO SERVERS NEEDED and also technologies like Elastic Cloud Compute(EC2) for servers, Amazon Simple Storage Service (S3) for storage, and many more waiting for you to be discovered!

Sources

Serverless Computing - AWS Lambda
How to Make a Serverless Website with AWS Lambda (for free)
Beginners Guide To Building a Serverless Website with AWS Lambda and API Gateway
How to create a FREE AWS account and understand the Free Tier: A beginner's guide