DEV Community: Željko Šević

Infrastructure as Code (IaC) with Terraform (AWS EC2 Example)

Željko Šević — Tue, 28 Apr 2026 10:02:38 +0000

Infrastructure as Code (IaC) is a DevOps approach where infrastructure is defined and managed using code instead of manual setup. This makes environments reproducible, version-controlled, and easy to scale.

In this guide, you'll provision an AWS EC2 instance using Terraform.

Requirements

Before starting, install:

Terraform
AWS CLI

AWS Credentials Setup

Go to IAM → Security credentials in AWS
Create access keys
Configure locally:

aws configure

This stores credentials in:

~/.aws/credentials
~/.aws/config

Project Structure

A simple Terraform setup:

.
├── main.tf
├── variables.tf
├── terraform.tfvars
├── outputs.tf

Provider Configuration

Define your cloud provider in main.tf:

provider "aws" {
  profile = "default"
  region  = "eu-north-1"
}

Variables

Define reusable variables in variables.tf:

variable "instance_name" {
  description = "Name tag for EC2 instance"
  type        = string
  default     = "MyNewInstance"
}

variable "ec2_instance_type" {
  description = "EC2 instance type"
  type        = string
  default     = "t3.micro"
}

Set values in terraform.tfvars:

instance_name      = "MyEC2Name"
ec2_instance_type  = "t3.micro"

EC2 Instance Configuration

Add the resource in main.tf:

resource "aws_instance" "app_server" {
  ami           = "ami-077d1b9f9a1902bbc"
  instance_type = var.ec2_instance_type

  tags = {
    Name = var.instance_name
  }
}

You can find AMI IDs in EC2 → Images → AMI Catalog.

Outputs

Expose useful data in outputs.tf:

output "instance_id" {
  description = "EC2 instance ID"
  value       = aws_instance.app_server.id
}

output "instance_public_ip" {
  description = "Public IP address"
  value       = aws_instance.app_server.public_ip
}

Terraform Workflow

Initialize the project:

terraform init

Preview changes:

terraform plan

Apply changes:

terraform apply

Destroy infrastructure:

terraform destroy

Important Notes

State file

Terraform stores infrastructure state in terraform.tfstate.

Do not commit this file to Git.

Remote state (recommended)

For teams, store state in S3 with locking via DynamoDB.

Idempotency

Running apply multiple times won’t recreate resources unnecessarily.

Version control

Treat Terraform code like application code.

Load and stress testing with Artillery

Željko Šević — Sat, 25 Apr 2026 13:52:36 +0000

Artillery is a performance testing tool. This post explains types of performance testing and dives into Artillery usage, from configuration to running tests and checking results.

Load and stress testing

Load and stress testing are two types of performance testing used to evaluate how well a system performs under various conditions.

Load testing determines how the system performs under expected user loads. The purpose is to identify performance bottlenecks.

Stress testing assesses how the system performs when loads are heavier than usual. The purpose is to find the limit at which the system fails and to observe how it recovers from such failures.

Prerequisites

Artillery available via npx (or installed in project dev dependencies)
YAML config file that defines target, phases and scenarios
Optional CSV payload file for dynamic test data

Configuration

Artillery test configuration is defined in a YAML file (for example, .artillery/main.yml). It typically contains:

target: base URL of the app (http://localhost:3000)
phases: load shape over time
payload: CSV file for dynamic values
scenarios: user flows and weights

For realistic load tests, configure these parts intentionally:

Define phases for warm-up, ramp-up, and sustained load.
Use a CSV payload when requests require dynamic values (IDs, emails, tokens, and similar).
Use weighted scenarios to simulate realistic traffic distribution across endpoints.

config:
  target: 'http://localhost:3000'
  phases:
    - duration: 30
      arrivalRate: 5
      name: Warm up
    - duration: 30
      arrivalRate: 5
      rampTo: 50
      name: Ramp up load
    - duration: 30
      arrivalRate: 50
      name: Sustained load
  payload:
    path: 'dynamic_data.csv'
    fields:
      - 'CustomerId'
scenarios:
  - name: "Get customer's tracks"
    flow:
      - get:
          url: '/customers/{{ CustomerId }}/tracks'
    weight: 4
  - name: 'Get customers pdf'
    flow:
      - get:
          url: '/customers/pdf'
    weight: 1

Scenario flow and dynamic data

Scenarios define user actions during the test.

In the example:

80% of users run Get customer's tracks (weight: 4)
20% of users run Get customers pdf (weight: 1)

Dynamic data is loaded from .artillery/dynamic_data.csv, and {{ CustomerId }} is injected into request URLs.

Running tests

Load tests can be executed through an npm script:

"scripts": {
  "test:load": "artillery run ./.artillery/main.yml"
}

Run the test with:

npm run test:load

You can also run Artillery directly with npx:

npx artillery run ./.artillery/main.yml

Test report

By default, Artillery prints a terminal summary with key metrics such as:

failed virtual users and HTTP error/status-code distribution
response-time percentiles (especially p95 and p99)
median response time (p50)
requests per second and total request volume

To save raw results and generate an HTML report:

npx artillery run --output report.json ./.artillery/main.yml
npx artillery report report.json --output report.html

This generates a shareable HTML report with latency percentiles, throughput and error trends.

When reading Artillery reports, focus on these metrics first:

Error rate (vusers.failed, non-2xx/3xx codes): the most important health signal. Even small error percentages can indicate instability under load.
Tail latency (p95, p99): shows worst-case user experience. Systems can have a good median but still feel slow for a significant group of users.
Median latency (p50/median): useful for baseline responsiveness, but should always be evaluated together with p95/p99.
Throughput (http.requests, requests/sec): confirms how much traffic the system handled during the test.
Trend over time (intermediate snapshots): helps identify whether performance degrades during ramp-up or sustained load.

In short: start with reliability (errors), then check latency percentiles (especially p95/p99), and finally validate throughput and time-based stability.

HTTP timeout with Axios

Željko Šević — Wed, 25 Sep 2024 23:29:23 +0000

Setting up a timeout for HTTP requests can prevent the connection from hanging forever, waiting for the response. It can be set on the client side to improve user experience, and on the server side to improve inter-service communication.

axios package provides a timeout parameter for this functionality.

const HTTP_TIMEOUT = 3000;
const URL = 'https://www.google.com:81';

(async () => {
  try {
    await axios(URL, {
      timeout: HTTP_TIMEOUT,
    });
  } catch (error) {
    console.error('Request timed out', error.cause);
  }
})();

Use this snippet also to simulate aborted requests.

Course

Build your SaaS in 2 weeks - Start Now

RabbitMQ container with Docker Compose

Željko Šević — Mon, 02 Sep 2024 21:57:30 +0000

Docker Compose facilitates spinning up a container for the RabbitMQ broker without installing it locally.

Prerequisites

Docker Compose installed

Configuration

The following configuration spins up the RabbitMQ container with the management UI tool.

The connection string for the RabbitMQ broker with local virtual host is amqp://localhost:5672/local.

RabbitMQ management UI is available at the http://localhost:15672 link. Default credentials are guest as username and guest as password.

# docker-compose.yml
version: '3.8'

services:
  rabbitmq:
    image: rabbitmq:3-management
    ports:
      - 5672:5672
      - 15672:15672
    environment:
      - RABBITMQ_DEFAULT_VHOST=local
    volumes:
      - 'rabbitmq_data:/data'

volumes:
  rabbitmq_data:

Run the following command to spin up the container.

docker-compose up

Course

Build your SaaS in 2 weeks - Start Now

Simulating keyboard typing with JavaScript

Željko Šević — Wed, 21 Aug 2024 18:33:32 +0000

Simulating keyboard typing in JavaScript can be useful for automating tasks or testing applications. The KeyboardEvent API allows developers to trigger keyboard events programmatically.

Examples

The snippet below simulates pressing the Ctrl + Enter command. The bubbles flag ensures the event moves up through the DOM, so any elements higher up in the document can also detect and respond to it.

const event = new KeyboardEvent('keydown', {
  key: 'Enter',
  ctrlKey: true,
  bubbles: true,
});

document.dispatchEvent(event);

The snippet below simulates pressing the Shift + Enter command on a specific input field.

const event = new KeyboardEvent('keydown', {
  key: 'Enter',
  shiftKey: true,
  bubbles: true,
});

document.querySelector('input').dispatchEvent(event);

Course

Build your SaaS in 2 weeks - Start Now

Profiling Node.js apps with Chrome DevTools profiler

Željko Šević — Fri, 05 Jul 2024 00:22:43 +0000

Profiling refers to analyzing and measuring an application's performance characteristics.

Profiling helps identify performance bottlenecks in a Node.js app, such as CPU-intensive tasks like cryptographic operations, image processing, or complex calculations.

This post covers running a profiler for various Node.js apps in Chrome DevTools.

Prerequisites

Google Chrome installed
Node.js app bootstrapped

Setup

Run node --inspect app.js to start the debugger.
Open chrome://inspect, click Open dedicated DevTools for Node and then navigate to the Performance tab. Start recording.
Run load testing via autocannon package using the following command format npx autocannon <COMMAND>.
Stop recording in Chrome DevTools.

Profiling

On Perfomance tab in Chrome DevTools open Bottom-Up subtab to identify which functions consume the most time.

Look for potential performance bottlenecks, such as synchronous functions for hashing (pbkdf2Sync) or file system operations (readFileSync).

Course

Build your SaaS in 2 weeks - Start Now

Load and stress testing with k6

Željko Šević — Fri, 10 May 2024 20:47:16 +0000

k6 is a performance testing tool. This post explains types of performance testing and dives into k6 usage, from configuration to running tests.

Load and stress testing

Load and stress testing are two types of performance testing used to evaluate how well a system performs under various conditions.

Load testing determines how the system performs under expected user loads. The purpose is to identify performance bottlenecks.

Stress testing assesses how the system performs when loads are heavier than usual. The purpose is to find the limit at which the system fails and to observe how it recovers from such failures.

Prerequisites

k6 installed
Script (Node.js) file with configuration and execution function

Configuration

Configuration is stored inside options variable, which allows you to set up different testing scenarios:

constant user load, the number of virtual users (vus) remains constant throughout the test period

export const options = {
  vus: 30,
  duration: '10m'
};

variable user load, the number of users increases and decreases over time

export const options = {
  stages: [
    {
      duration: '1m',
      target: 30
    },
    {
      duration: '10m',
      target: 30
    },
    {
      duration: '5m',
      target: 0
    }
  ]
};

Environment variables can be passed through the command line and are accessible within the script via the __ENV object.

k6 -e TOKEN=token run script.js

Execution function

This function defines what virtual users will do during the test. This function is called for each virtual user and typically includes steps that simulate user actions on the app.

export default function() {
  http.get(URL);
  // Add more actions as required
}

Test report

k6 generates a report that provides detailed insights into various benchmarks, such as the number of virtual users, requests per second, request durations and error rates.

Example

This example utilizes k6 to conduct a load test using a variable user load approach:

User simulation: The script ramps up to 1,000 users, maintains that level to simulate sustained traffic, and gradually reduces to zero.
Request handling: During the test, each virtual user sends a POST request to an API, with pauses between requests to mimic real user behavior.
Performance insights: After the test, k6 provides a report that shows key information, such as how fast the app responds and how many requests fail.

Run it via k6 -e TOKEN=1234 run script.js command.

// script.js
import { check, sleep } from 'k6';
import { scenario } from 'k6/execution';
import http from 'k6/http';

export const options = {
  stages: [
    // Ramp up to 1000 users over 10 minutes
    {
      duration: '10m',
      target: 1000
    },
    // Hold 1000 users for 30 minutes
    {
      duration: '30m',
      target: 1000
    },
    // Ramp down to 0 users over 5 minutes
    {
      duration: '5m',
      target: 0
    }
  ]
};

export default () => {
  const response = http.post(
    URL,
    JSON.stringify({
      iteration: scenario.iterationInTest
    }),
    {
      headers: {
        Authorization: __ENV.TOKEN,
        'Content-Type': 'application/json'
      }
    }
  );

  check(response, {
    'response status was 200': (res) => res.status === 200
  });

  sleep(1);
};

Course

Build your SaaS in 2 weeks - Start Now

Node Version Manager (nvm) overview

Željko Šević — Wed, 08 May 2024 23:31:11 +0000

nvm facilitates switching between different Node versions across projects. This post covers its overview from installation to version management.

Installation

To install nvm, execute the following commands in your terminal. This example uses zsh, but the process is similar for other shells like bash.

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
source ~/.zshrc

Version management

Install the specific version. Including the v prefix is optional.

nvm install v21.7.2

Install the latest version

nvm install node

Install the latest one for the specified major version

nvm install 22

Switch to a specific installed version

nvm use 21

Add .nvmrc file inside the project directory and run nvm use command to use the specified installed version.

v21.7.2

Get the list of locally installed versions

nvm ls

Get the list of available versions for installation

nvm ls-remote

Course

Build your SaaS in 2 weeks - Start Now

Debugging Node.js apps with Chrome DevTools debugger

Željko Šević — Thu, 11 Apr 2024 23:59:52 +0000

Debugging with a debugger and breakpoints is recommended rather than using console logs. Chrome provides a built-in debugger for JavaScript-based apps.

This post covers configuring and running a debugger for various Node.js apps in Chrome DevTools.

Prerequisites

Google Chrome installed
Node.js app bootstrapped

Setup

Open chrome://inspect, click Open dedicated DevTools for Node and open the Connection tab. You should see a list of network endpoints for debugging.

Run node --inspect-brk app.js to start the debugger, it will log the debugger network. Choose the network in Chrome to open the debugger in Chrome DevTools.

Debugging basics

The variables tab shows local and global variables during debugging.

The step over next function call option goes to the following statement in the codebase, while the step into next function call option goes deeper into the current statement.

Add logs in the debug console via logpoints by selecting the specific part of the codebase so it logs when the selected codebase executes.

Course

Build your SaaS in 2 weeks - Start Now

Sending e-mails with Sendgrid

Željko Šević — Sat, 30 Mar 2024 00:44:02 +0000

To send e-mails in a production environment, use services like Sendgrid.

Verify the e-mail address on the Sender Management page and create the SendGrid API key on the API keys page.

import nodemailer from 'nodemailer';

(async () => {
  const emailConfiguration = {
    auth: {
      user: process.env.EMAIL_USERNAME, // 'apikey'
      pass: process.env.EMAIL_PASSWORD
    },
    host: process.env.EMAIL_HOST, // 'smtp.sendgrid.net'
    port: process.env.EMAIL_PORT, // 465
    secure: process.env.EMAIL_SECURE, // true
  };

  const transport = nodemailer.createTransport(emailConfiguration);

  const info = await transport.sendMail({
    from: '"Sender" <sender@example.com>',
    to: 'recipient1@example.com, recipient2@example.com',
    subject: 'Subject',
    text: 'Text',
    html: '<b>Text</b>'
  });

  console.log('Message sent: %s', info.messageId);
})();

Course

Build your SaaS in 2 weeks - Start Now

MongoDB containers with Docker Compose

Željko Šević — Fri, 02 Feb 2024 20:31:00 +0000

Docker Compose facilitates spinning up a container for the MongoDB database without installing MongoDB locally.

Prerequisites

Docker Compose installed

Configuration

The following configuration spins up the MongoDB container with the UI tool (Mongo Express).

The connection string for the MongoDB database is mongodb://localhost:27018.

Mongo Express is available at the http://localhost:8082 link. Use the below Basic auth credentials to log in to Mongo Express.

# docker-compose.yml
version: '3.8'

services:
  mongo:
    image: 'mongo:7.0.5'
    ports:
      - 27018:27017
    volumes:
      - my-data:/var/lib/mongodb/data

  mongo-express:
    image: 'mongo-express:1.0.2'
    ports:
      - 8082:8081
    environment:
      ME_CONFIG_BASICAUTH_USERNAME: username
      ME_CONFIG_BASICAUTH_PASSWORD: password

volumes:
  my-data:

Run the following command to spin up the containers.

docker-compose up

Course

Build your SaaS in 2 weeks - Start Now

Web scraping with cheerio

Željko Šević — Fri, 19 Jan 2024 19:11:30 +0000

Web scraping means extracting data from websites. This post covers extracting data from the page's HTML tags.

Prerequisites

cheerio package is installed
HTML page is retrieved via an HTTP client

Usage

create a scraper object with load method by passing HTML content as an argument
- set decodeEntities option to false to preserve encoded characters (like &) in their original form

  const $ = load('<div><!-- HTML content --></div>', { decodeEntities: false });

find DOM elements by using CSS-like selectors

  const items = $('.item');

iterate through found elements using each method

  items.each((index, element) => {
    // ...
  });

access element content using specific methods

text $(element).text()
HTML $(element).html()
attributes
- all $(element).attr()
- specific one $(element).attr('href')
child elements
- first $(element).first()
- last $(element).last()
- all $(element).children()
- specific one $(element).find('a')
siblings
- previous $(element).prev()
- next $(element).next()

Disclaimer

Please check the website's terms of service before scraping it. Some websites may have terms of service that prohibit such activity.

Course

Build your SaaS in 2 weeks - Start Now