Forem: Deividas Strole

Build a Node.js HTTP Server From Scratch (No Frameworks Needed and Less Then 30 Lines!)

Deividas Strole — Mon, 16 Mar 2026 23:08:42 +0000

Most Node.js tutorials jump straight to Express. But before you reach for a framework, it's worth understanding what's happening underneath — because once you do, everything else clicks.

In this tutorial, Deividas Strole walks you through building a simple HTTP server using only Node's built-in modules. No Express, no npm install, no dependencies of any kind. Just the runtime doing its thing.

By the end, you'll have a working local server that serves a static HTML file — and a much clearer mental model of how the web actually works.

What You'll Learn

How the Node.js http module handles requests and responses
How to read files from disk using the fs module
How to serve a static HTML page
How to handle 404 routes cleanly
How to run everything locally in under a minute

Prerequisites

Node.js installed (nodejs.org)
Basic JavaScript knowledge
A text editor (VS Code, Vim, anything works)

No package manager needed. We're going fully built-in.

Step 1: Create the HTML File

First, create index.html. This is what your server will send to the browser.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
  <title>My Node Server</title>
  <style>
    body {
      font-family: monospace;
      background: #0d1117;
      color: #e6edf3;
      display: flex;
      align-items: center;
      justify-content: center;
      min-height: 100vh;
      margin: 0;
    }
    h1 { color: #3fb950; }
    p  { color: #8b949e; }
  </style>
</head>
<body>
  <div>
    <h1>✓ Server is running</h1>
    <p>Served by Node.js — no frameworks needed.</p>
  </div>
</body>
</html>

Simple, clean, and it'll look great in the browser.

Step 2: Create the Server

Now create server.js. This is where the magic happens.

const http = require('http');
const fs   = require('fs');
const path = require('path');

const PORT      = process.env.PORT || 3000;
const HTML_FILE = path.join(__dirname, 'index.html');

const server = http.createServer((req, res) => {
  // Only serve the root route
  if (req.url === '/' || req.url === '/index.html') {
    fs.readFile(HTML_FILE, (err, data) => {
      if (err) {
        res.writeHead(500, { 'Content-Type': 'text/plain' });
        res.end('500 Internal Server Error');
        return;
      }
      res.writeHead(200, { 'Content-Type': 'text/html' });
      res.end(data);
    });
  } else {
    // Everything else gets a 404
    res.writeHead(404, { 'Content-Type': 'text/plain' });
    res.end('404 Not Found');
  }
});

server.listen(PORT, () => {
  console.log(`✅ Server running at http://localhost:${PORT}`);
});

That's it. 30 lines. Let's break down what each part does.

Step 3: Run It

In your terminal, navigate to your project folder and run:

node server.js

Open your browser and go to http://localhost:3000. You'll see your HTML page served by your own server.
Try visiting http://localhost:3000/anything-else — you'll get the 404 response.
To stop the server, press Ctrl + C.

Full Source Code

The complete project is on GitHub:
👉 github.com/deividas-strole/node-js-server
Drop a ⭐ if you found it useful.

Super Simple Web Scraping in Java (Jsoup)

Deividas Strole — Mon, 16 Feb 2026 00:51:43 +0000

Lets create a super-duper simple web scraper with Java! For that we will need Java, Jsoup, 5 minutes and a good mood!

Add Jsoup

<dependency> 
    <groupId>org.jsoup</groupId> 
    <artifactId>jsoup</artifactId> 
    <version>1.17.2</version> 
</dependency>

Create super-duper minimal scraper

In this our example we will print all links (text and URL) from a page:

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;

public class SimpleScraper {
    public static void main(String[] args) throws Exception {
        String url = "https://example.com"; // change this 

        Document doc = Jsoup.connect(url).get(); 

        for (Element link : doc.select("a[href]")) {            
            System.out .println(link.text() + " -> " + link.absUrl("href")); 
        }
    }
}

Thats it!!!! You are done! No models, No JSON, and no extra libraries!

Extra credit: If you want something spacific - change the selector.

Examples:

Article titles: h1, h2, h3
Product cards: .product
Price: .price
Any element by id: #price

Example: print all <h2> titles:

for (Element h : doc.select("h2")) {
  System.out.println(h.text());
}

More extra credit: In this code, the request originates from a Java client, which many websites will identify as a bot. As a result, they may block your access. To make your scraper appear as though it is coming from a real user, include this line before .get():

.userAgent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36")

Happy Coding!!!

About the Author

Deividas Strole is a Full-Stack Developer based in California, specializing in Java, Spring Boot, React, and AI-driven development. He writes about software engineering, modern full-stack development, and digital marketing strategies.

Connect with me:

Complete Java Tutorial: From Zero to Building Real Applications

Deividas Strole — Sun, 01 Feb 2026 18:53:14 +0000

Introduction

Java is one of the oldest and most popular programming languages in the world. It is a general-purpose programming language, which means you can do with it everything... well, maybe not everything, but almost everything :)
With Java, you can do Android Mobile Development, Enterprise Applications, Web Applications, Big Data Technologies, Cloud-Based Applications, Financial Services, Scientific Applications, Game Development, Internet of Things (IoT), and other stuff... In this tutorial, you'll learn Java fundamentals and build practical projects along the way.

What you'll learn:

Java basics and syntax
Object-Oriented Programming concepts
Working with collections and data structures
File handling and exception management
Building a real-world console application

Prerequisites: Basic computer literacy. No prior programming experience required!

Part 1: Setting Up Your Java Environment

Installing Java Development Kit (JDK)

Download the latest JDK from Oracle or OpenJDK
Install and verify by opening terminal/command prompt:

java -version
javac -version

Choosing an IDE
Go with one of these:

IntelliJ IDEA Community Edition (beginner-friendly and my favorite!)
Eclipse (lightweight)
VS Code with Java extensions (if you're already familiar with VS Code)

Part 2: Your First Java Program

Let's start now with the classic "Hello, World!" program:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Breaking it down:

public class HelloWorld - Defines a class named HelloWorld
public static void main(String[] args) - The entry point of every Java program
System.out.println() - Prints text to the console

To run:

Save as HelloWorld.java
Compile: javac HelloWorld.java
Run: java HelloWorld

Part 3: Java Fundamentals

Variables and Data Types
Java is statically typed, meaning you must declare variable types:

public class DataTypes {
    public static void main(String[] args) {
        // Primitive types
        int age = 25;
        double price = 19.99;
        boolean isActive = true;
        char grade = 'A';

        // String (reference type)
        String name = "Alice";

        // Printing variables
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
        System.out.println("Price: $" + price);
    }
}

Common data types:

int - integers (whole numbers)
double - decimal numbers
boolean - true/false
char - single character
String - text

Operators

public class Operators {
    public static void main(String[] args) {
        int a = 10, b = 3;

        // Arithmetic operators
        System.out.println("Addition: " + (a + b));       // 13
        System.out.println("Subtraction: " + (a - b));    // 7
        System.out.println("Multiplication: " + (a * b)); // 30
        System.out.println("Division: " + (a / b));       // 3
        System.out.println("Modulus: " + (a % b));        // 1

        // Comparison operators
        System.out.println("Is equal: " + (a == b));      // false
        System.out.println("Is greater: " + (a > b));     // true

        // Logical operators
        boolean x = true, y = false;
        System.out.println("AND: " + (x && y));           // false
        System.out.println("OR: " + (x || y));            // true
        System.out.println("NOT: " + (!x));               // false
    }
}

Part 4: Control Flow

If-Else Statements

public class ControlFlow {
    public static void main(String[] args) {
        int score = 85;

        if (score >= 90) {
            System.out.println("Grade: A");
        } else if (score >= 80) {
            System.out.println("Grade: B");
        } else if (score >= 70) {
            System.out.println("Grade: C");
        } else {
            System.out.println("Grade: F");
        }
    }
}

Loops

public class Loops {
    public static void main(String[] args) {
        // For loop
        System.out.println("For loop:");
        for (int i = 1; i <= 5; i++) {
            System.out.println("Count: " + i);
        }

        // While loop
        System.out.println("\nWhile loop:");
        int j = 1;
        while (j <= 5) {
            System.out.println("Count: " + j);
            j++;
        }

        // Enhanced for loop (for arrays)
        System.out.println("\nEnhanced for loop:");
        String[] fruits = {"Apple", "Banana", "Orange"};
        for (String fruit : fruits) {
            System.out.println(fruit);
        }
    }
}

Switch Statement

public class SwitchExample {
    public static void main(String[] args) {
        String day = "Monday";

        switch (day) {
            case "Monday":
                System.out.println("Start of the work week!");
                break;
            case "Friday":
                System.out.println("Almost weekend!");
                break;
            case "Saturday":
            case "Sunday":
                System.out.println("Weekend!");
                break;
            default:
                System.out.println("Midweek day");
        }
    }
}

Part 5: Methods and Functions

Methods help organize code into reusable blocks:

public class Methods {
    // Method with no parameters and no return value
    public static void greet() {
        System.out.println("Hello!");
    }

    // Method with parameters
    public static void greetUser(String name) {
        System.out.println("Hello, " + name + "!");
    }

    // Method with return value
    public static int add(int a, int b) {
        return a + b;
    }

    // Method with multiple parameters and return value
    public static double calculateArea(double length, double width) {
        return length * width;
    }

    public static void main(String[] args) {
        greet();
        greetUser("Alice");

        int sum = add(5, 3);
        System.out.println("Sum: " + sum);

        double area = calculateArea(5.5, 3.2);
        System.out.println("Area: " + area);
    }
}

Part 6: Object-Oriented Programming (OOP)

Classes and Objects
Java is an object-oriented language. Everything revolves around objects:

// Define a class
class Car {
    // Properties (fields)
    String brand;
    String model;
    int year;

    // Constructor
    public Car(String brand, String model, int year) {
        this.brand = brand;
        this.model = model;
        this.year = year;
    }

    // Method
    public void displayInfo() {
        System.out.println(year + " " + brand + " " + model);
    }

    public void honk() {
        System.out.println("Beep beep!");
    }
}

public class OOPExample {
    public static void main(String[] args) {
        // Create objects
        Car car1 = new Car("Toyota", "Camry", 2023);
        Car car2 = new Car("Honda", "Civic", 2022);

        // Use objects
        car1.displayInfo();
        car1.honk();

        car2.displayInfo();
    }
}

Encapsulation (Getters and Setters)

class BankAccount {
    // Private fields (encapsulated)
    private String accountNumber;
    private double balance;

    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        this.balance = initialBalance;
    }

    // Getter methods
    public String getAccountNumber() {
        return accountNumber;
    }

    public double getBalance() {
        return balance;
    }

    // Setter with validation
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposited: $" + amount);
        } else {
            System.out.println("Invalid deposit amount");
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("Withdrawn: $" + amount);
        } else {
            System.out.println("Invalid withdrawal amount");
        }
    }
}

public class EncapsulationDemo {
    public static void main(String[] args) {
        BankAccount account = new BankAccount("123456", 1000.0);

        System.out.println("Balance: $" + account.getBalance());
        account.deposit(500);
        account.withdraw(200);
        System.out.println("Final balance: $" + account.getBalance());
    }
}

Inheritance

// Parent class
class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void eat() {
        System.out.println(name + " is eating");
    }

    public void sleep() {
        System.out.println(name + " is sleeping");
    }
}

// Child class
class Dog extends Animal {
    public Dog(String name) {
        super(name);  // Call parent constructor
    }

    public void bark() {
        System.out.println(name + " says: Woof!");
    }
}

class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    public void meow() {
        System.out.println(name + " says: Meow!");
    }
}

public class InheritanceDemo {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
        dog.eat();
        dog.bark();

        Cat cat = new Cat("Whiskers");
        cat.sleep();
        cat.meow();
    }
}

Polymorphism

class Shape {
    public void draw() {
        System.out.println("Drawing a shape");
    }

    public double getArea() {
        return 0;
    }
}

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }

    @Override
    public double getArea() {
        return width * height;
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        // Polymorphism: treating different objects through same interface
        Shape[] shapes = {
            new Circle(5),
            new Rectangle(4, 6),
            new Circle(3)
        };

        for (Shape shape : shapes) {
            shape.draw();
            System.out.println("Area: " + shape.getArea());
            System.out.println();
        }
    }
}

Part 7: Arrays and Collections

Arrays

public class ArraysDemo {
    public static void main(String[] args) {
        // Declare and initialize array
        int[] numbers = {1, 2, 3, 4, 5};

        // Access elements
        System.out.println("First element: " + numbers[0]);

        // Array length
        System.out.println("Length: " + numbers.length);

        // Iterate through array
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("numbers[" + i + "] = " + numbers[i]);
        }

        // 2D array
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };

        System.out.println("Element at [1][2]: " + matrix[1][2]); // 6
    }
}

ArrayList

import java.util.ArrayList;

public class ArrayListDemo {
    public static void main(String[] args) {
        // Create ArrayList
        ArrayList<String> fruits = new ArrayList<>();

        // Add elements
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Orange");

        // Access elements
        System.out.println("First fruit: " + fruits.get(0));

        // Size
        System.out.println("Size: " + fruits.size());

        // Iterate
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // Remove element
        fruits.remove("Banana");

        // Check if contains
        if (fruits.contains("Apple")) {
            System.out.println("We have apples!");
        }
    }
}

HashMap

import java.util.HashMap;

public class HashMapDemo {
    public static void main(String[] args) {
        // Create HashMap
        HashMap<String, Integer> scores = new HashMap<>();

        // Add key-value pairs
        scores.put("Alice", 95);
        scores.put("Bob", 87);
        scores.put("Charlie", 92);

        // Get value by key
        System.out.println("Alice's score: " + scores.get("Alice"));

        // Iterate through HashMap
        for (String name : scores.keySet()) {
            System.out.println(name + ": " + scores.get(name));
        }

        // Check if key exists
        if (scores.containsKey("Bob")) {
            System.out.println("Bob is in the system");
        }
    }
}

Part 8: Exception Handling

public class ExceptionHandling {
    public static void main(String[] args) {
        // Try-catch block
        try {
            int result = divide(10, 0);
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("Error: Cannot divide by zero!");
        }

        // Multiple catch blocks
        try {
            String text = null;
            System.out.println(text.length());
        } catch (NullPointerException e) {
            System.out.println("Error: Null reference!");
        } catch (Exception e) {
            System.out.println("Some other error occurred");
        } finally {
            System.out.println("This always executes");
        }
    }

    public static int divide(int a, int b) {
        return a / b;
    }
}

Custom Exceptions

// Custom exception class
class InsufficientFundsException extends Exception {
    public InsufficientFundsException(String message) {
        super(message);
    }
}

class BankAccountAdvanced {
    private double balance;

    public BankAccountAdvanced(double balance) {
        this.balance = balance;
    }

    public void withdraw(double amount) throws InsufficientFundsException {
        if (amount > balance) {
            throw new InsufficientFundsException(
                "Insufficient funds. Balance: $" + balance + ", Requested: $" + amount
            );
        }
        balance -= amount;
        System.out.println("Withdrawn: $" + amount);
    }

    public double getBalance() {
        return balance;
    }
}

public class CustomExceptionDemo {
    public static void main(String[] args) {
        BankAccountAdvanced account = new BankAccountAdvanced(100);

        try {
            account.withdraw(150);
        } catch (InsufficientFundsException e) {
            System.out.println("Transaction failed: " + e.getMessage());
        }
    }
}

Part 9: File Handling

import java.io.*;
import java.util.Scanner;

public class FileHandling {

    // Writing to a file
    public static void writeToFile(String filename, String content) {
        try {
            FileWriter writer = new FileWriter(filename);
            writer.write(content);
            writer.close();
            System.out.println("Successfully wrote to file");
        } catch (IOException e) {
            System.out.println("Error writing to file: " + e.getMessage());
        }
    }

    // Reading from a file
    public static void readFromFile(String filename) {
        try {
            File file = new File(filename);
            Scanner reader = new Scanner(file);

            while (reader.hasNextLine()) {
                String line = reader.nextLine();
                System.out.println(line);
            }
            reader.close();
        } catch (FileNotFoundException e) {
            System.out.println("File not found: " + e.getMessage());
        }
    }

    public static void main(String[] args) {
        String filename = "example.txt";

        // Write to file
        writeToFile(filename, "Hello, Java!\nThis is file handling in action.");

        // Read from file
        System.out.println("Reading from file:");
        readFromFile(filename);
    }
}

Part 10: Real-World Project - Task Manager Application

Let's build a complete console-based task manager:

import java.util.ArrayList;
import java.util.Scanner;

class Task {
    private String title;
    private String description;
    private boolean completed;

    public Task(String title, String description) {
        this.title = title;
        this.description = description;
        this.completed = false;
    }

    public String getTitle() { return title; }
    public String getDescription() { return description; }
    public boolean isCompleted() { return completed; }

    public void setCompleted(boolean completed) {
        this.completed = completed;
    }

    @Override
    public String toString() {
        String status = completed ? "[✓]" : "[ ]";
        return status + " " + title + " - " + description;
    }
}

class TaskManager {
    private ArrayList<Task> tasks;

    public TaskManager() {
        tasks = new ArrayList<>();
    }

    public void addTask(String title, String description) {
        tasks.add(new Task(title, description));
        System.out.println("Task added successfully!");
    }

    public void listTasks() {
        if (tasks.isEmpty()) {
            System.out.println("No tasks found.");
            return;
        }

        System.out.println("\n===== YOUR TASKS =====");
        for (int i = 0; i < tasks.size(); i++) {
            System.out.println((i + 1) + ". " + tasks.get(i));
        }
        System.out.println("======================\n");
    }

    public void completeTask(int index) {
        if (index >= 0 && index < tasks.size()) {
            tasks.get(index).setCompleted(true);
            System.out.println("Task marked as complete!");
        } else {
            System.out.println("Invalid task number.");
        }
    }

    public void deleteTask(int index) {
        if (index >= 0 && index < tasks.size()) {
            tasks.remove(index);
            System.out.println("Task deleted!");
        } else {
            System.out.println("Invalid task number.");
        }
    }
}

public class TaskManagerApp {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        TaskManager manager = new TaskManager();
        boolean running = true;

        System.out.println("===== TASK MANAGER =====");

        while (running) {
            System.out.println("\nOptions:");
            System.out.println("1. Add Task");
            System.out.println("2. List Tasks");
            System.out.println("3. Complete Task");
            System.out.println("4. Delete Task");
            System.out.println("5. Exit");
            System.out.print("Choose an option: ");

            int choice = scanner.nextInt();
            scanner.nextLine(); // Consume newline

            switch (choice) {
                case 1:
                    System.out.print("Enter task title: ");
                    String title = scanner.nextLine();
                    System.out.print("Enter task description: ");
                    String description = scanner.nextLine();
                    manager.addTask(title, description);
                    break;

                case 2:
                    manager.listTasks();
                    break;

                case 3:
                    manager.listTasks();
                    System.out.print("Enter task number to complete: ");
                    int completeIndex = scanner.nextInt() - 1;
                    manager.completeTask(completeIndex);
                    break;

                case 4:
                    manager.listTasks();
                    System.out.print("Enter task number to delete: ");
                    int deleteIndex = scanner.nextInt() - 1;
                    manager.deleteTask(deleteIndex);
                    break;

                case 5:
                    System.out.println("Goodbye!");
                    running = false;
                    break;

                default:
                    System.out.println("Invalid option. Try again.");
            }
        }

        scanner.close();
    }
}

Best Practices and Tips

1. Naming Conventions

Classes: Use PascalCase (e.g., MyClass, BankAccount)
Methods and variables: Use camelCase (e.g., calculateTotal, userName)
Constants: Use UPPER_SNAKE_CASE (e.g., MAX_SIZE, DEFAULT_VALUE)

2. Code Organization

One public class per file
File name must match the public class name
Use packages to organize related classes

3. Comments and Documentation

/**
 * Calculates the factorial of a number
 * @param n the number to calculate factorial for
 * @return the factorial of n
 */
public static long factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

4. Always Use Try-With-Resources

// Good practice - automatically closes resources
try (Scanner scanner = new Scanner(new File("data.txt"))) {
    while (scanner.hasNextLine()) {
        System.out.println(scanner.nextLine());
    }
} catch (FileNotFoundException e) {
    e.printStackTrace();
}

What's Next?
Now that you've learned Java fundamentals, here are some paths to explore:

Web Development: Learn Spring Boot for building web applications
Android Development: Create mobile apps with Android Studio
Data Structures & Algorithms: Deepen your problem-solving skills
Design Patterns: Learn common solutions to recurring problems
Testing: Explore JUnit for unit testing

Recommended Resources

Official Java Documentation: docs.oracle.com/javase
Practice coding: LeetCode, HackerRank, Codewars
Java communities: r/learnjava, Stack Overflow

Conclusion
Congratulations! You've learned Java from the basics to building a real application. The key to mastering Java is practice, practice, practice, and practice. Try building your own projects. Start with small ones and go up in size. Also, open an account on GitHub (Free!) and put all your learning and projects there for everybody to see! Don't forget to contribute to open-source, and keep coding every day.
What will you build with Java? Drop a comment below and share your projects!
Happy coding! ☕

If you found this tutorial helpful, please give it a ❤️ and follow for more programming tutorials!

About the Author

Deividas Strole is a Full-Stack Developer based in California, specializing in Java, Spring Boot, JavaScript, React, SQL, and AI-driven development. He writes about software engineering, modern full-stack development, and digital marketing strategies.

Connect with me:

Building Your First AI Client in Java (Cerebras AI)

Deividas Strole — Sun, 18 Jan 2026 20:48:51 +0000

In this tutorial, you'll learn how to build a very simple AI chat client in Java. Because of the free tier and the speed, we will be using Cerebras AI here. The same principles though apply to other AI providers like OpenAI (ChatGPT), Claude, or Gemini. If you decide to use other AI models — just adjust the API endpoint and model names.

Prefer video? You can watch the full tutorial on YouTube above.

What You'll Need

Java 11 or higher (we'll use the modern HttpClient API)
A Cerebras AI API key
Your favorite IDE or text editor

Step 1: Get Your Cerebras API Key

First, you'll need to get an API key from Cerebras:

Visit Cerebras AI and sign up for an account
Navigate to the API section or developer dashboard
Generate a new API key
Copy the key—you'll need it in the next step

... and of course - keep your API key secure and never commit it to version control!

Step 2: Set Up Your API Key as an Environment Variable

Instead of hardcoding your API key in your source code, store it as an environment variable. This keeps your key secure and makes your code more portable.

On Windows
Open Command Prompt or PowerShell and run:
SETX CEREBRAS_API_KEY "your-api-key-here"

Replace your-api-key-here with your actual API key. You'll need to restart your IDE or terminal for the changes to take effect.

On macOS/Linux
Add this line to your ~/.bashrc, ~/.zshrc, or ~/.bash_profile:
export CEREBRAS_API_KEY="your-api-key-here"

Then reload your configuration:
bashsource ~/.bashrc # or ~/.zshrc

Step 3: Create Your Java Project

Create a new Java file called AIChat.java and add the following code:

javaimport java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class AIChat {
    public static void main(String[] args) throws IOException, InterruptedException {
        String apiKey = System.getenv("CEREBRAS_API_KEY");

        String requestBody = """
        {
            "model": "llama3.1-8b",
            "messages": [
                {"role": "user", "content": "How to win a lotto?"}
            ],
            "temperature": 0.2
        }
        """;

        HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create("https://api.cerebras.ai/v1/chat/completions"))
                .header("Content-Type", "application/json")
                .header("Authorization", "Bearer " + apiKey)
                .POST(HttpRequest.BodyPublishers.ofString(requestBody))
                .build();

        HttpClient client = HttpClient.newHttpClient();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

        System.out.println(response.body());
    }
}

Understanding the Code

Let's break down what this code does:

1. Reading the API Key
String apiKey = System.getenv("CEREBRAS_API_KEY");

This retrieves your API key from the environment variable you set earlier.

2. Building the Request Body

String requestBody = """
{
    "model": "llama3.1-8b",
    "messages": [
        {"role": "user", "content": "How to win a lotto?"}
    ],
    "temperature": 0.2
}
""";

The request body is a JSON object containing:

model: The AI model to use (Cerebras offers various Llama models)
messages: An array of message objects with roles and content
temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)

3. Creating the HTTP Request

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.cerebras.ai/v1/chat/completions"))
    .header("Content-Type", "application/json")
    .header("Authorization", "Bearer " + apiKey)
    .POST(HttpRequest.BodyPublishers.ofString(requestBody))
    .build();

This builds an HTTP POST request with:

The Cerebras API endpoint
JSON content type header
Authorization header with your API key
The request body we created

4. Sending the Request

HttpClient client = HttpClient.newHttpClient();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println(response.body());

This creates an HTTP client, sends the request, and prints the JSON response.

Step 4: Run Your Application
Compile and run your program:

javac AIChat.java
java AIChat

You should see a JSON response containing the AI's answer!

Parsing the JSON Response

The raw JSON response isn't very user-friendly. Let's improve our code to extract just the AI's message. You can use a JSON library like Gson or Jackson, or parse it manually for simple cases:

// Add this method to extract the content
private static String extractContent(String jsonResponse) {
    int contentStart = jsonResponse.indexOf("\"content\":\"") + 11;
    int contentEnd = jsonResponse.indexOf("\"", contentStart);
    return jsonResponse.substring(contentStart, contentEnd)
        .replace("\\n", "\n");
}

// In main, replace the println with:
String aiResponse = extractContent(response.body());
System.out.println("AI Response: " + aiResponse);

Adapting to Other AI Providers

Want to use a different AI provider? Here's what you need to change:

OpenAI (ChatGPT)

Endpoint: https://api.openai.com/v1/chat/completions
Model: gpt-4 or gpt-3.5-turbo
API Key env var: OPENAI_API_KEY

Anthropic (Claude)

Endpoint: https://api.anthropic.com/v1/messages
Model: claude-sonnet-4-5-20250929
Headers: Add "x-api-key" instead of "Authorization"
API Version: Add header "anthropic-version": "2023-06-01"

Google (Gemini)

Endpoint: https://generativelanguage.googleapis.com/v1/models/gemini-pro:generateContent?key=YOUR_KEY
Different request format (check Google's documentation)

Next Steps

Now that you have a working AI client, you can:

Add user input to make it interactive
Implement conversation history by maintaining a messages array
Add error handling for network issues and API errors
Parse JSON responses properly using Gson or Jackson
Create a command-line chat interface
Experiment with different models and temperature settings

Conclusion

Congratulations - you have successfully built your first AI client in Java! Yahoo! This simple example demonstrates the core concepts you'll use regardless of which AI provider you choose. The key takeaways are understanding HTTP requests, JSON formatting, and secure API key management.

Happy coding, and enjoy exploring the world of AI integration!

About the Author

Connect with me:

AI-Powered Commit Message Generator with Sring Boot & Cerebras

Deividas Strole — Mon, 12 Jan 2026 04:29:32 +0000

I don't know anyone who likes writing proper commit messages. Everyone knows they have to write them, but most are too lazy to think a good message and compose one. I, for example, am so lazy that even for 'work in progress' I just type 'wip'... In this tutorial we will create a REST API which will take your git diff (differences between versions of your code) and automatically generate a professional commit message. Magic!

Our battle plan:

A simple Spring Boot REST API
Integration with Cerebras Cloud API
One endpoint: send a diff, get a formatted commit message

Why Cerebras?

They give free API keys if you ask nicely! Shhh... it's a secret! Also—their API is OpenAI-compatible! ;)

Prerequisites

Java 17+
Maven
A Cerebras API key (get free credits at https://cloud.cerebras.ai)
Basic Spring Boot knowledge

Project Setup

1. Create Spring Boot Project
Using Spring Initializr, create a project with these dependencies:

Spring Web
Spring WebFlux
Lombok
Validation

Or use this pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
         https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.2.0</version>
    </parent>

    <groupId>com.example</groupId>
    <artifactId>commit-message-generator</artifactId>
    <version>1.0.0</version>

    <properties>
        <java.version>17</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

2. Application Configuration
Create src/main/resources/application.properties:

# Cerebras API Configuration
cerebras.api-key=${CEREBRAS_API_KEY}
cerebras.api-url=https://api.cerebras.ai/v1/chat/completions
cerebras.model=llama3.1-70b

# Server Configuration
server.port=8080

# Logging
logging.level.com.example.commitgen=INFO

Building the Application

1. Configuration Class
Create src/main/java/com/example/commitgen/config/CerebrasConfig.java:

package com.example.commitgen.config;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import lombok.Data;

@Configuration
@ConfigurationProperties(prefix = "cerebras")
@Data
public class CerebrasConfig {
    private String apiKey;
    private String apiUrl;
    private String model;
}

2. DTOs (Data Transfer Objects)

Create src/main/java/com/example/commitgen/dto/CommitRequest.java:

package com.example.commitgen.dto;

import jakarta.validation.constraints.NotBlank;
import lombok.Data;

@Data
public class CommitRequest {
    @NotBlank(message = "Diff cannot be empty")
    private String diff;

    private String type; // feat, fix, docs, etc. (optional)
    private String scope; // Optional scope
}

Create src/main/java/com/example/commitgen/dto/CommitResponse.java:

package com.example.commitgen.dto;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommitResponse {
    private String message;
    private String type;
    private String scope;
    private String description;
    private String body;
}

Create Cerebras API DTOs in src/main/java/com/example/commitgen/dto/CerebrasRequest.java:

package com.example.commitgen.dto;

import com.fasterxml.jackson.annotation.JsonProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import java.util.List;

@Data
@AllArgsConstructor
public class CerebrasRequest {
    private String model;
    private List<Message> messages;

    @JsonProperty("max_tokens")
    private Integer maxTokens;

    private Double temperature;

    @Data
    @AllArgsConstructor
    public static class Message {
        private String role;
        private String content;
    }
}

Create src/main/java/com/example/commitgen/dto/CerebrasResponse.java:

package com.example.commitgen.dto;

import lombok.Data;
import java.util.List;

@Data
public class CerebrasResponse {
    private List<Choice> choices;

    @Data
    public static class Choice {
        private Message message;

        @Data
        public static class Message {
            private String role;
            private String content;
        }
    }
}

3. Cerebras API Service

Create src/main/java/com/example/commitgen/service/CerebrasService.java:

package com.example.commitgen.service;

import com.example.commitgen.config.CerebrasConfig;
import com.example.commitgen.dto.CerebrasRequest;
import com.example.commitgen.dto.CerebrasResponse;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

import java.util.List;

@Service
@RequiredArgsConstructor
@Slf4j
public class CerebrasService {

    private final CerebrasConfig config;
    private final WebClient.Builder webClientBuilder;

    public Mono<String> generateCompletion(String prompt) {
        WebClient webClient = webClientBuilder
            .baseUrl(config.getApiUrl())
            .defaultHeader("Authorization", "Bearer " + config.getApiKey())
            .defaultHeader("Content-Type", "application/json")
            .build();

        CerebrasRequest request = new CerebrasRequest(
            config.getModel(),
            List.of(
                new CerebrasRequest.Message("system", 
                    "You are a helpful assistant that generates conventional commit messages."),
                new CerebrasRequest.Message("user", prompt)
            ),
            500,
            0.3
        );

        return webClient.post()
            .bodyValue(request)
            .retrieve()
            .bodyToMono(CerebrasResponse.class)
            .map(response -> {
                if (response.getChoices() != null && !response.getChoices().isEmpty()) {
                    return response.getChoices().get(0).getMessage().getContent();
                }
                throw new RuntimeException("No response from Cerebras API");
            })
            .doOnError(error -> log.error("Error calling Cerebras API", error));
    }
}

4. Commit Message Service

Create src/main/java/com/example/commitgen/service/CommitMessageService.java:

package com.example.commitgen.service;

import com.example.commitgen.dto.CommitRequest;
import com.example.commitgen.dto.CommitResponse;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import reactor.core.publisher.Mono;

@Service
@RequiredArgsConstructor
@Slf4j
public class CommitMessageService {

    private final CerebrasService cerebrasService;

    public Mono<CommitResponse> generateCommitMessage(CommitRequest request) {
        String prompt = buildPrompt(request);

        return cerebrasService.generateCompletion(prompt)
            .map(this::parseResponse)
            .onErrorResume(error -> {
                log.error("Error generating commit message", error);
                return Mono.just(createErrorResponse());
            });
    }

    private String buildPrompt(CommitRequest request) {
        StringBuilder prompt = new StringBuilder();

        prompt.append("Based on the following git diff, generate a conventional commit message.\n\n");
        prompt.append("Format:\n");
        prompt.append("<type>(<scope>): <description>\n\n");
        prompt.append("<body>\n\n");
        prompt.append("Where:\n");
        prompt.append("- type: feat, fix, docs, style, refactor, test, chore\n");
        prompt.append("- scope: optional, component/file affected\n");
        prompt.append("- description: brief summary (50 chars max)\n");
        prompt.append("- body: detailed explanation (optional)\n\n");

        if (request.getType() != null) {
            prompt.append("Preferred type: ").append(request.getType()).append("\n");
        }
        if (request.getScope() != null) {
            prompt.append("Scope: ").append(request.getScope()).append("\n");
        }

        prompt.append("\nDiff:\n");
        prompt.append(request.getDiff());
        prompt.append("\n\n");
        prompt.append("Return ONLY the commit message in the format specified above. ");
        prompt.append("Do not include any explanations or additional text.");

        return prompt.toString();
    }

    private CommitResponse parseResponse(String response) {
        // Clean up the response
        String cleaned = response.trim();

        // Parse conventional commit format
        String[] lines = cleaned.split("\n", 2);
        String firstLine = lines[0].trim();
        String body = lines.length > 1 ? lines[1].trim() : "";

        // Extract type, scope, and description
        String type = "";
        String scope = "";
        String description = firstLine;

        // Parse: type(scope): description
        if (firstLine.contains(":")) {
            String[] parts = firstLine.split(":", 2);
            String prefix = parts[0].trim();
            description = parts.length > 1 ? parts[1].trim() : "";

            if (prefix.contains("(") && prefix.contains(")")) {
                int scopeStart = prefix.indexOf("(");
                int scopeEnd = prefix.indexOf(")");
                type = prefix.substring(0, scopeStart).trim();
                scope = prefix.substring(scopeStart + 1, scopeEnd).trim();
            } else {
                type = prefix;
            }
        }

        return new CommitResponse(
            cleaned,
            type,
            scope,
            description,
            body
        );
    }

    private CommitResponse createErrorResponse() {
        return new CommitResponse(
            "chore: update files",
            "chore",
            "",
            "update files",
            "Failed to generate AI-powered commit message. Using default."
        );
    }
}

5. REST Controller

Create src/main/java/com/example/commitgen/controller/CommitController.java:

package com.example.commitgen.controller;

import com.example.commitgen.dto.CommitRequest;
import com.example.commitgen.dto.CommitResponse;
import com.example.commitgen.service.CommitMessageService;
import jakarta.validation.Valid;
import lombok.RequiredArgsConstructor;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Mono;

@RestController
@RequestMapping("/api/v1/commit")
@RequiredArgsConstructor
@CrossOrigin(origins = "*")
public class CommitController {

    private final CommitMessageService commitMessageService;

    @PostMapping("/generate")
    public Mono<ResponseEntity<CommitResponse>> generateCommitMessage(
            @Valid @RequestBody CommitRequest request) {
        return commitMessageService.generateCommitMessage(request)
            .map(ResponseEntity::ok);
    }

    @GetMapping("/health")
    public ResponseEntity<String> health() {
        return ResponseEntity.ok("Commit Message Generator is running!");
    }
}

6. Main Application

Create src/main/java/com/example/commitgen/CommitMessageGeneratorApplication.java:

package com.example.commitgen;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.reactive.function.client.WebClient;

@SpringBootApplication
public class CommitMessageGeneratorApplication {

    public static void main(String[] args) {
        SpringApplication.run(CommitMessageGeneratorApplication.class, args);
    }

    @Bean
    public WebClient.Builder webClientBuilder() {
        return WebClient.builder();
    }
}

Running the Application

1. Set Your API Key
export CEREBRAS_API_KEY=your-api-key-here

2. Start the Application
bashmvn spring-boot:run

Conclusion

You have built functional AI commit message generator in under 200 lines!!! Et voilà !

About the Author

Connect with me:

How to Optimize Your Personal Website for Keywords: A Simple Guide

Deividas Strole — Mon, 05 Jan 2026 00:09:54 +0000

How to Optimize Your Personal Website for Keywords: A Simple Guide

When you are building a website, you want it to be not only visually nice, but also discoverable by other people. To achieve that you need to adjust the code and text for keywords - words that people will look for. I created this guide using my name as an example. You can freely copy and use the code for your own keywords though.

Why Keyword Optimization Matters

When someone searches for your name, or professional identity your personal website should appear in the top results. This is especially important for:

Building your professional brand
Getting found by clients and recruiters
Establishing credibility in your field
Controlling your online narrative

The techniques in this guide not only work for classical Search Engine Optimization, but also are a must have for Artificial Intelligence Optimization in 2026. We will use SEO and AIO interchangeably in this guide.

The Foundation: Semantic HTML Structure

Search engines and AI love well-structured HTML. Start with proper semantic elements:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Deividas Strole - Web Developer</title>
</head>
<body>
    <header>
        <h1>Deividas Strole</h1>
        <nav><!-- Navigation --></nav>
    </header>
    <main>
        <section><!-- Content --></section>
    </main>
    <footer><!-- Footer --></footer>
</body>
</html>

Critical Meta Tags for SEO/AIO

Your <head> section is prime real estate for SEO and AIO. Here are the essential meta tags:

1. Title Tag

The title tag is the most important on-page SEO/AIO element. It appears in search results and browser tabs.

<title>Deividas Strole - Web Developer</title>

Best practices:

Keep it under 60 characters
Include your primary keyword (your name or your product) at the beginning
Add a secondary keyword or descriptor
Make it compelling and click-worthy

2. Meta Description

While not a direct ranking factor, the meta description influences click-through rates:

<meta name="description" content="Deividas Strole is a web developer specializing in Java, JavaScript, and SQL. Explore my portfolio, projects, and get in touch for collaborations.">

Best practices:

Keep it between 150-160 characters
Include your keyword naturally
Write for humans, not just search engines
Include a call-to-action

3. Open Graph Tags

These tags control how your site appears when shared on social media:

<meta property="og:title" content="Deividas Strole - Web Developer Portfolio">
<meta property="og:description" content="Explore the portfolio and projects of Deividas Strole, a web developer specializing in modern web technologies.">
<meta property="og:image" content="https://deividasstrole.com/images/deividas-strole-lawander-sc.png">
<meta property="og:url" content="https://deividasstrole.com">
<meta property="og:type" content="website">

4. Twitter Card Tags

Similar to Open Graph, but for X (Twitter) - this is what is shown if your website is shared on X (Twitter):

<meta name="twitter:card" content="summary_large_image">
<meta name="twitter:title" content="Deividas Strole - Web Developer">
<meta name="twitter:description" content="Web developer specializing in modern applications and user experiences.">
<meta name="twitter:image" content="https://yourwebsite.com/images/twitter-card.jpg">

Strategic Keyword Placement

Now that the foundation is set, let's strategically place your keyword throughout the page:

1. H1 Heading

Your H1 should contain your primary keyword and appear only once per page:

<h1>Deividas Strole</h1>

2. Subheadings (H2, H3)

Use related keywords and variations in subheadings:

<h2>About Deividas Strole</h2>
<h2>Projects by Deividas Strole</h2>
<h3>Contact Deividas Strole</h3>

3. First Paragraph

Include your keyword in the opening paragraph naturally:

<section>
    <p>Hello! I'm <strong>Deividas Strole</strong>, a web developer passionate about creating elegant solutions to complex problems. With expertise in modern web technologies, I help businesses build exceptional digital experiences.</p>
</section>

4. Image Alt Text

Search engines can't "see" images, but they read alt text:

<img src="profile.jpg" alt="Deividas Strole - Web Developer">
<img src="project1.jpg" alt="E-commerce website designed by Deividas Strole">

5. Internal Links

Create descriptive anchor text with your keyword:

<a href="#about">Learn more about Deividas Strole</a>
<a href="#portfolio">View Deividas Strole's portfolio</a>

Structured Data (Schema.org)

Help search engines understand your content better with JSON-LD structured data:

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "Person",
  "name": "Deividas Strole",
  "url": "https://deividasstrole.com",
  "jobTitle": "Web Developer",
  "description": "Web developer specializing in modern web applications",
  "sameAs": [
    "https://linkedin.com/in/deividas-strole",
    "https://github.com/deividas-strole",
    "https://youtube.com/@deividas-strole",
    "https://x.com/deividasstrole"
  ]
}
</script>

This creates a "Knowledge Graph" that can appear in search results.

Technical SEO Considerations

1. URL Structure

Keep your URLs clean and keyword-rich:

✅ yourwebsite.com/deividas-strole
✅ deividasstrole.com
❌ yourwebsite.com/page?id=12345

2. Canonical Tag

Prevent duplicate content issues:

<link rel="canonical" href="https://yourwebsite.com/">

3. Favicon

While not directly impacting SEO, a favicon improves brand recognition:

<link rel="icon" type="image/png" href="/favicon.png">

4. Mobile Optimization

Google uses mobile-first indexing, so ensure your viewport meta tag is set:

<meta name="viewport" content="width=device-width, initial-scale=1.0">

Content Strategy for Personal Brands

Beyond technical optimization, create content that naturally incorporates your keyword:

About Section

<section id="about">
    <h2>About Deividas Strole</h2>
    <p>Deividas Strole is a web developer with 5+ years of experience building scalable applications. Specializing in Java, JavaScript, Spring Boot, React, SQL, and AI, Deividas helps startups and enterprises transform their digital presence.</p>
</section>

Portfolio/Projects

<section id="portfolio">
    <h2>Projects by Deividas Strole</h2>
    <article>
        <h3>E-commerce Platform</h3>
        <p>Deividas Strole designed and developed a full-stack e-commerce solution processing 10,000+ daily transactions.</p>
    </article>
</section>

Avoiding Keyword Stuffing

While you want to include your keyword, don't overdo it. Aim for a keyword density of 1-2%. For a 500-word page, that's 5-10 mentions. Focus on natural language and user experience first.

Bad example (keyword stuffing):

"Deividas Strole is the best developer. Deividas Strole builds websites. If you need Deividas Strole, contact Deividas Strole today."

Good example:

"As a web developer, I help clients to solve all their web related problems. My approach is hard work, no sleep, and hundred cups of coffee. All this combined deliver unseen and unheard incredible results... :D"

Performance Optimization

Page speed is a ranking factor. Optimize your index.html:

Minimize HTML: Remove unnecessary whitespace and comments
Optimize images: Use WebP format and appropriate dimensions
Lazy load: Load images below the fold lazily
Inline critical CSS: Include above-the-fold styles in <head>
Defer JavaScript: Use defer or async attributes

<script src="script.js" defer></script>

Complete Example

Here's a simplified but optimized index.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Deividas Strole - Web Developer & Designer</title>
    <meta name="description" content="Deividas Strole is a web developer specializing in modern web applications. Explore projects, skills, and get in touch for collaborations.">
    <link rel="canonical" href="https://deividasstrole.com/">

    <!-- Open Graph -->
    <meta property="og:title" content="Deividas Strole - Web Developer">
    <meta property="og:description" content="Portfolio and projects of web developer Deividas Strole.">
    <meta property="og:image" content="https://deividasstrole.com/images/deividas-strole-lawander-sc.png">
    <meta property="og:url" content="https://deividasstrole.com">

    <!-- Structured Data -->
    <script type="application/ld+json">
    {
      "@context": "https://schema.org",
      "@type": "Person",
      "name": "Deividas Strole",
      "url": "https://deividasstrole.com",
      "jobTitle": "Web Developer"
    }
    </script>
</head>
<body>
    <header>
        <h1>Deividas Strole</h1>
        <nav>
            <a href="#about">About</a>
            <a href="#portfolio">Portfolio</a>
            <a href="#contact">Contact</a>
        </nav>
    </header>

    <main>
        <section id="hero">
            <h2>Web Developer & Designer</h2>
            <p>Hello! I'm <strong>Deividas Strole</strong>, a passionate developer creating modern web experiences.</p>
        </section>

        <section id="about">
            <h2>About Deividas Strole</h2>
            <img src="profile.jpg" alt="Deividas Strole profile photo">
            <p>With expertise in modern web technologies, I help businesses build exceptional digital products that users love.</p>
        </section>

        <section id="portfolio">
            <h2>Featured Projects</h2>
            <article>
                <h3>Project Name</h3>
                <img src="project.jpg" alt="Web application by Deividas Strole">
                <p>A responsive web application built with React and Node.js.</p>
            </article>
        </section>

        <section id="contact">
            <h2>Get in Touch</h2>
            <p>Interested in working together? <a href="mailto:hello@example.com">Contact Deividas Strole</a></p>
        </section>
    </main>

    <footer>
        <p>&copy; 2024 Deividas Strole. All rights reserved.</p>
    </footer>
</body>
</html>

Monitoring and Iteration

After implementing these optimizations:

Submit to Google Search Console: Monitor how your site appears in search
Check Google Analytics: Track organic traffic and user behavior
Test with PageSpeed Insights: Ensure fast loading times
Monitor rankings: Use tools like Ahrefs or SEMrush to track keyword positions
Update regularly: Fresh content signals to search engines and AI that your site is active and not forgotten.

Conclusion

Optimizing your personal website for keywords is interesting but tedious job. You need to start with the code and finish with the content of your website itself. This guide is a good start and will give you nice fundament on which you can build your brand and strong online presence.

Remember, SEO and AIO is a marathon, not sprint. To see results, you need weeks if not months. But it is doable and rewarding.

Now go and optimize your index.html - Internet is waiting for you!

About the Author

Connect with me:

💡 How to Install Gemini CLI on Your Computer

Deividas Strole — Mon, 29 Dec 2025 01:43:24 +0000

Gemini CLI is a great open source command line tool that lets you use Google's Gemini on your computer right in the terminal. You can install and use it on Windows, Mac, or Linux. It can help you with code development, file and project management, and AI-powered assistance. Why I like and use it is also not only because it is a very powerful tool, but also because of its cost - or in reality - no cost! For individuals, it has a 1000 requests per day limit, which is way too much for the average user (60 requests per minute). So, try it, see if you like it, and comment under the article. Now, let's install it:

🛠 Prerequisites

Node.js (v20 or higher) — this provides the runtime environment Gemini CLI needs.
A working terminal.

🚀 Step 1 — Install Gemini CLI

npm install -g @google/gemini-cli

▶️ Step 2 — Launch Gemini CLI

In your command-line shell type:

gemini

🔑 Step 3 — Authenticate

You will need to log in with your Google account - that is how Google will track how many requests you make. But don't worry, they are giving more than needed for an average user.

🧪 Step 4 — Try a Command!

Enter a prompt and wait for an answer. My question about why the sky is blue—it took 9 seconds to answer :)

About the Author

Connect with me:

Buying Web Traffic (Part 2): Targeting Mistakes and How to Spot Fake Traffic

Deividas Strole — Sun, 21 Dec 2025 21:24:23 +0000

In Part 1, I covered why people buy web traffic and when it can make sense as a growth tool. In this follow-up, I want to focus on what actually determines whether paid traffic helps—or quietly drains your budget: proper targeting and the ability to recognize fake traffic before it causes damage.

Category Selection Is Not Optional

One of the easiest ways to waste money on traffic is choosing the wrong audience category.

Traffic providers often let you select interests or verticals. If those don’t align with your site, conversions won’t happen—no matter how “high quality” the traffic claims to be.

For example, sending automotive-focused users to a gardening website won’t produce engagement. Even real people won’t take action if the content doesn’t match their intent. Relevance always comes first.

Before buying traffic, be clear about:

What problem your site solves
Who is actively looking for that solution
Which categories naturally overlap with your content

Geography Matters More Than People Expect

Geographic targeting mistakes are another common failure point.

If your product is only available in specific countries, traffic from outside those regions has zero business value. Selling UK-only products to visitors from Southeast Asia won’t lead to conversions, even if the traffic is real.

When setting location targeting, think through:

Where you can actually ship or operate
Which languages your site supports
Regional legal or compliance restrictions
Payment methods available in each country

Getting this right takes a few minutes, but getting it wrong can invalidate an entire campaign.

The Real Risk: Fake Traffic

The biggest danger when buying traffic isn’t poor targeting—it’s fake traffic.

Fake traffic (often called “ghost” traffic) is generated by automated systems, not real people. These systems simulate visits well enough that many analytics tools treat them like normal users.

That’s why fake traffic is hard to detect at first glance. Bots don’t announce themselves; they just quietly inflate numbers while producing no real engagement.

How to Tell If Traffic Is Real

You won’t identify fake traffic by looking at surface-level metrics. Instead, focus on behavior patterns.

Average Session Duration

Session duration shows how long visitors stay on your page.

Organic traffic from search engines typically averages around 40–60 seconds for informational pages. Fake traffic, on the other hand, often results in session durations close to zero because bots don’t interact with content.

If you see sudden spikes in traffic paired with near-instant exits, that’s a strong warning sign.

Bounce Rate

Bounce rate measures how many users leave after viewing just one page.

While bounce rate varies by site type (blogs and news sites naturally have higher rates), fake traffic often pushes bounce rate close to 100%. That indicates visitors are arriving and leaving without any interaction at all.

A consistently extreme bounce rate combined with low session duration is rarely normal.

Pageviews per Session

Real users behave differently: some read one page and leave, others click deeper into the site.

With fake traffic, pageviews per session are usually flat—often stuck at exactly one. Bots don’t browse; they hit a URL and disappear.

Percent of New Sessions

When you buy traffic, it’s expected that most visitors are new at first. Seeing close to 100% new sessions initially is normal.

What matters is what happens afterward. Over time, real users return. If weeks go by and every visitor is still “new,” that suggests the traffic isn’t human.

Metrics That Don’t Help Much

Some commonly referenced metrics aren’t useful for detecting fake traffic.

Sessions

A session simply records a visit—human or bot. Automated traffic can generate sessions that look perfectly valid in analytics.

Users

Similarly, the “users” metric counts anything that has at least one session. It doesn’t reliably distinguish real people from automated signals.

These metrics are fine for volume tracking, but they won’t help you assess traffic quality.

How to Avoid Fake Traffic Providers

You can often spot low-quality or scam providers before spending any money.

Things to check:

Website quality: Poor design, broken English, or vague explanations are red flags.
Business details: Legitimate providers list real addresses and company information.
Google Maps presence: A verified listing with reviews adds credibility.
External reviews: Look beyond testimonials hosted on the provider’s own site.
Small test orders: Always test with minimal spend before scaling.
Refund policy: Clear replacement or refund terms indicate confidence in traffic quality.

If a provider avoids transparency or guarantees “instant conversions,” that’s usually a bad sign.

Final Thoughts

Buying web traffic isn’t inherently good or bad—it’s a tool. Used carefully, it can help validate content, test funnels, or accelerate visibility. Used carelessly, it can inflate metrics while delivering no real value.

The basics matter:

Target the right audience category
Match traffic to your geographic reality
Monitor behavioral metrics, not just volume
Test small before committing
Avoid providers that hide details or overpromise

About the Author

Connect with me:

Personal Website: https://DeividasStrole.com
LinkedIn: https://linkedin.com/in/deividas-strole
GitHub: https://github.com/deividas-strole
YouTube: https://youtube.com/@deividas-strole

How to Buy Web Traffic: A Technical Guide for Developers and Online Businesses

Deividas Strole — Mon, 15 Dec 2025 00:25:19 +0000

There are plenty of tutorials on building web applications, but there's surprisingly little reliable information on how to actually get users to visit them. In this article, I'll explain how to acquire visitors and convert them into users through the process of buying internet traffic. I'll cover the technical aspects, analytics, and implementation details. After reading this, you'll know enough to make an informed decision about whether traffic buying makes sense for your project.

If you're thinking about buying web traffic, you're making a practical choice. Targeted web traffic is affordable, you have full control of the entire process, it has a clear payment model, robust monitoring tools, and measurable financial and SEO benefits.

How Traffic Buying Works Technically

When you buy web traffic from a reputable provider, you control exactly how many visitors you get when you place an order. Unlike other digital advertising models, you pay only for a certain number of visitors that will be directed to your website. There's no guessing here. If you're running an e-commerce site and need to stress-test your infrastructure or increase conversions this month, you can order 10,000 potential customers to be delivered to your application. 10,000 visitors will be delivered and your metrics will increase.

Payment and Delivery Process

Reputable web traffic providers use straightforward payment models. You pay for traffic first, then your payment and website are approved, and finally you get the agreed amount of visitors delivered to your site. The entire process can take a couple of hours, but sometimes up to 24 hours. The more visitors you order, the more potential users you'll get. It's up to you how much traffic to order. For a modest increase in user numbers, you can order 5,000 to 10,000, but for a bigger spike you can get up to 250,000 visitors.

Campaign Duration Control

When you buy web traffic, you decide how long your traffic campaigns should last. In other words, you decide over how many days you should receive all the visitors. To boost your numbers quickly, some site owners order their entire inventory to be delivered in a few days. If you're looking for slower, more sustainable growth, you can order inventory to be delivered over 30 or 60 days. High concentrations of traffic are not recommended for sites hosted on weaker servers or shared hosting.

Geographical Targeting via IP

Web traffic gives you the ability to decide which geographical location your traffic should come from. For example, some applications serve only certain regions, so they're not interested in global traffic (and vice versa). Reputable web traffic providers cover almost all major geographical areas. Visitor providers determine the location of a visitor from their IP address—similar to how you might implement geolocation in your own application.

Cost Comparison with PPC

Targeted web traffic prices are very stable and low. They're much lower than the popular Pay-Per-Click model. The reason is that traffic recipients (customers) don't have to compete with each other like in some other digital advertising models. Also, there are no keyword auctions, which makes the business environment more predictable. You can still find reputable web traffic providers (VisitorMaker.com, for example) who can send you 5,000 quality visitors for less than $10.

Category Targeting Implementation

When you buy web traffic, you choose a category that best describes your website. How does a website traffic provider know which visitor is interested in which category? The provider places advertisements on various websites and domains. If a visitor likes an advertisement displaying women's shoes, for example, and clicks on it, they'll be redirected to a website that selected women's shoes as its category. It's essentially a retargeting mechanism. When you buy traffic, you can select only one category per order. Those who want to receive traffic for multiple categories will need to place separate traffic orders for each one.

Analytics and Monitoring Tools

When you buy web traffic, you get monitoring tools to track your incoming visitors. Although Google Analytics is a great tool for analyzing website data, it's not optimal for tracking incoming targeted traffic. Most web traffic providers use third-party cookies which aren't readable by Google Analytics.

Alternative tracking solutions:

Goo.gl (Google's URL shortener): Excellent for tracking and verifying incoming web traffic
StatCounter.com: Third-party web statistics tracker
HitStats.com: Another viable third-party tracking option

These tools can give you more accurate data about your purchased traffic than GA alone.

SEO Impact (Yes, It Actually Helps)

Contrary to what some developers think, buying web traffic doesn't harm a website's SEO. Moreover, it helps SEO! The more visitors a website gets, the more SEO points are given by Google to improve the website's authority. Google tracks a website's popularity using data from:

Google Analytics
Google Search Console (Webmaster Tools)
Chrome Browser telemetry
Google Toolbar
Google Search itself

In this very competitive internet landscape, for an online business to succeed, you need all the SEO benefits you can get.

Development and Operations Benefits

The process of buying web traffic drastically decreases workload. Just imagine how much time you can save by eliminating manual marketing work? Instead of spending time on SEO optimization, content marketing, and social media management, you can focus on what you do best: building and improving your application.

Many successful businesses operate by using web traffic buying as their primary marketing strategy, allowing their development teams to focus on product rather than promotion. Don't forget that the visitors you're getting from a provider aren't only your potential users, but also your potential advocates who might share your site with others.

Scalability and Testing Benefits

When you buy web traffic from a reputable provider, you'll be serviced by a professional who knows their niche. The advantage of specialization is clear: better results with less effort on your part. Instead of maintaining the business, updating the website, and doing marketing, a website owner should outsource less familiar areas to other professionals.

Cost perspective: You can get 5,000 quality targeted visitors for less than $10. Compare that to the hourly rate of a developer or marketer working on organic growth strategies.

No Long-Term Commitments

The majority of web visitor providers don't use contracts with their clients. You pay as you go and you won't have to sign any contracts. This is particularly useful for developers and startups because:

Business goals and advertising strategies change
You can pivot quickly without contractual obligations
You can easily test different business categories
You can adjust geographical targeting on the fly
No contract helps you A/B test the service with minimal risk

You can buy only a small amount of visitors and see if it works for your project before scaling up.

Conversion Rate Metrics

Although conversion rate is never guaranteed, when you buy web traffic from reputable providers, you can expect reasonable numbers. Conversion rate is the percentage of users who become paying customers (or take any desired action). The average conversion rate for a landing page is about 2.35%, while the highest is up to 11.5%.

Conversion rate has three main factors:

Landing page design - UX/UI quality, load time, mobile responsiveness
Attractiveness of the product or service - Value proposition, pricing, features
Web traffic quality - How well-targeted the visitors are

To achieve a good conversion rate, all three factors must be present. If any of these factors is missing, achieving good conversion rates will be difficult. So every developer must make sure that their application is ready to accept web traffic: clean design, natural navigation, optimized performance, and competitive pricing.

Network Effects and Viral Potential

By buying web traffic, you not only acquire potential users, but you also get potential advocates. Every visitor who comes to your site can become a free spokesperson if they really like your product or service. In today's viral society, it's really easy to share useful content with countless social media connections. Make your application that useful resource and the number of your visitors will skyrocket organically.

Load Testing Benefits

An often overlooked benefit: purchased traffic can serve as a real-world load test for your infrastructure. Unlike synthetic load testing tools, you're getting actual HTTP requests from real browsers and devices distributed geographically. This can help you identify:

Server bottlenecks under realistic traffic patterns
CDN configuration issues
Database query optimization opportunities
Frontend performance problems

Just make sure your hosting can handle the traffic volume you're ordering, especially if you're on shared hosting or lower-tier VPS plans.

In Part 2, we'll dive into the technical details of identifying and avoiding fake traffic providers, analyzing traffic quality through metrics, and how to verify you're getting real human visitors rather than bot traffic.

About the Author

Connect with me:

Building Your First REST API with Spring Boot

Deividas Strole — Mon, 08 Dec 2025 04:14:42 +0000

By Deividas Strole — Full-Stack Developer

Introduction

If you're a developer, you definitely know Spring Boot. Just last year we celebrated the 10-year anniversary of this super Java framework. And like the Java programming language itself, Spring Boot doesn't show its age and keeps going strong. It's still the most popular framework for building production REST APIs in Java.

In this tutorial, I'll walk you through building a simple REST API with Spring Boot for managing books—and you'll learn along the way. Great for beginners and those who already forgot! :)

What We'll Build
A Book API where you can:

Add a book
Get all books
Get a book by ID
Delete a book

Step 1: Create Project
Go to start.spring.io and select:

Project: Maven
Language: Java
Spring Boot: 3.2.0 or latest
Dependencies: Spring Web

Click "Generate" and unzip the project.

Step 2: Create Book Class
File: src/main/java/com/example/demo/Book.java

javapackage com.example.demo;

public class Book {
    private Long id;
    private String title;
    private String author;

    // Constructor
    public Book(Long id, String title, String author) {
        this.id = id;
        this.title = title;
        this.author = author;
    }

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }
}

Step 3: Create Controller
File: src/main/java/com/example/demo/BookController.java

javapackage com.example.demo;

import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/api/books")
public class BookController {

    private List<Book> books = new ArrayList<>();
    private Long nextId = 1L;

    // Get all books
    @GetMapping
    public List<Book> getAllBooks() {
        return books;
    }

    // Get book by ID
    @GetMapping("/{id}")
    public Book getBookById(@PathVariable Long id) {
        return books.stream()
                .filter(book -> book.getId().equals(id))
                .findFirst()
                .orElse(null);
    }

    // Add a new book
    @PostMapping
    public Book addBook(@RequestBody Book book) {
        book.setId(nextId++);
        books.add(book);
        return book;
    }

    // Delete a book
    @DeleteMapping("/{id}")
    public String deleteBook(@PathVariable Long id) {
        books.removeIf(book -> book.getId().equals(id));
        return "Book deleted";
    }
}

Step 4: Run the Application
File: src/main/java/com/example/demo/DemoApplication.java (already exists)

Just run this file. Your API will start on http://localhost:8080

Step 5: Test Your API
Open a new terminal and try these commands:

Add a book:

bash
curl -X POST http://localhost:8080/api/books \
  -H "Content-Type: application/json" \
  -d '{"title":"Harry Potter","author":"J.K. Rowling"}'

Get all books:

bash
curl http://localhost:8080/api/books

Get book by ID:

bash
curl http://localhost:8080/api/books/1

Delete a book:

bash
curl -X DELETE http://localhost:8080/api/books/1

How It Works

@RestController - tells Spring this class handles web requests
@RequestMapping("/api/books") - all endpoints start with /api/books
@GetMapping - handles GET requests (retrieve data)
@PostMapping - handles POST requests (create data)
@DeleteMapping - handles DELETE requests (remove data)
@RequestBody - converts JSON to Java object
@PathVariable - gets the ID from URL

And, you are finished!!! You have a working REST API with just 2 files (well, maybe 3 including the main application file :) ).

About the Author

Connect with me:

Three reasons why computer science is no longer sexy - for now

Deividas Strole — Tue, 09 Sep 2025 22:13:35 +0000

For many decades a computer science degree meant job security, high salary and different employer perks. Sometimes students even before graduation were fished out by companies for junior roles. The IT job market was so thin that the US started "importing" a lot of specialists from Asia and Eastern Europe. Just after the Covid pandemic ended, something weird and unexpected happened. Many big companies, such as Microsoft, Oracle, Google and Meta started massive layoffs. At the same time various AI models were released and started being used by companies. The last nail in the IT job market coffin was the amount of new graduates that US schools graduated into a very crippled IT job market.

Why the massive layoffs in the first place? During covid, the US economy suddenly changed to a work from home model. The usage of various software that made living and working at home without leaving for days increased drastically and many companies started unprecedented hiring campaigns. The boom suddenly ended when people realized that the Covid pandemic is over and that going outside and doing things the "old-fashioned way" makes more sense. The companies realized that they do not need those thousands of "extra workers" they hired, and with the prediction of slower economic growth they started reducing their workforce. Over 100,000 IT workers lost jobs in 2025.

At the same time the A.I. miracle happened. A.I. made it possible to create software faster, more or less semi-eliminating the need for junior programmers. If a piece of boilerplate code is already on the Internet, the A.I. can copy it and spit it out for a programmer in a few seconds. That, in theory, gives the impression that productivity increases and eliminates the need for junior roles. Almost all software companies started using AI code editors such as Cursor or GitHub Copilot. Although the "on paper" productivity increased, new issues with code security, limited testing, and unpredictable app behavior arose. In the beginning, that did not alarm many companies and they continued the AI over programmer preference business model.

The third reason for IT job challenges that we have these days is the amount of new computer science graduates. In less than a decade the graduating students with computer science degrees more than doubled. With the laid off experienced programmers taking sometimes even junior level jobs and AI improved code creation, many of the newly graduated professionals are left without a job.

It seems that computer science and tech employment dips are kind of cyclical. The dot-com bust of the 2000's and Great Recession 2008-2009 kind of predicted this 2020-2025 IT job volatility. Although AI changed how we write code, it did not replace engineers but more expanded their capabilities. Hopefully, we will emerge from all of this stronger and more productive.

Deividas Strole - navigating the world of AI

About the Author

Connect with me:

The Truth Behind Cheap Website Traffic

Deividas Strole — Tue, 29 Apr 2025 19:57:38 +0000

Introduction

There are many myths about cheap traffic buying. Some people swear by it and others avoid it. This article is the in-depth explanation what the cheap traffic is and its comparison with other digital marketing models such as Cost-Per-Click (CPC), Cost-Per-Mill (CPM), and Cost-Per-Acquisition (CPA).

To prosper online a website has to have a traffic flow... and lots of it. Website traffic can be obtained for free or can be bought.
Free traffic can be acquired by using search engine optimization (SEO) - a process of increasing visibility of a website in search engine result pages. Paid traffic can be obtained by using various internet marketing techniques that cost money. Cheap traffic is one of paid traffic models.

Cheap Traffic Bought in Bulk

Cheap traffic buying, also known as targeted traffic or bulk traffic buying, is an online marketing model where a website owner buys visitors in bulk. Traffic providers collect bulk traffic and redirect it to client’s website. They place ads on various websites and when visitors click on those advertisements they are re-directed to a client’s website. Usually, cheap traffic providers own a lot of websites, domains, and mobile apps and if needed can provide a lot of traffic. Traffic providers determine what a visitor is interested in by an advertisement that the visitor clicks on. If an individual clicks on an advertisement related to weight loss pills, for example, she will be redirected to a traffic buyer’s website who chose “Diet Supplements” as their category. The geographical location of a visitor is determined by his IP address. Cheap traffic is a quick way to increase potential customers to your site. It is also beneficial to website’s SEO and Alexa rankings. Read here for more information on how to buy website trafic.

Pros:

Price: Cheap traffic is really cheap, you can buy 5000 quality visitors for under $10.
Good Targeting: Website visitors are presorted by advertisements that they click on.
Flexibility: Traffic campaigns can be started and stopped in less than 24 hours.
Control over the budget: You pay only for visitors that you want to receive.
Testing capability: You can buy just a little number of traffic for testing purposes.
Quick results: You get potential customers to your website quickly.

Cons:

Possibility of fake traffic: There are websites selling fake traffic which doesn't work.

Cost-Per-Click (CPC) vs Cheap Traffic

Cost-Per-Click (CPC), also known as Pay-Per-Click (PPC), is a branch of digital marketing payment model where a website’s or app’s owner places someone's ad on his or her site and charges the advertiser when a visitor clicks on it. There is no charge if a visitor sees the advertisement, but does not click on it. Cost-Per-Click model is implemented a lot by search engines and social networking sites. CPC has better targeting than cheap traffic bought in bulk, but it is much more expensive. Like in cheap traffic model, visitor's location is determined by his or her ip address. Also, like cheap traffic, CPC is good for testing, brings quick results, and has pretty good control over budget.

Pros:

Excellent Targeting: Ads created for the advertiser with his keywords and products.
Flexibility: Traffic campaigns can be started and stopped quickly.
Control over the budget: You decide how much you want to spend.
Testing capability: You can spend minimum for testing purposes.
Quick results: You get potential customers to your website quickly.

Cons:

Cost: CPC costs much more then cheap traffic and prices fluctuate.
Bidding wars: If several websites want the same keyword, ad prices rise.
Click Fraud: Competitor or even traffic provider might abuse CPC model.
CPC requires skills: It is not so easy to conduct a successful CPC campaign.

Cost-Per-Mill (CPM) vs Cheap Traffic

Cost-Per-Mill (CPM), also called cost per thousand (CPT), is an online advertising pricing model where a website’s owner charges advertiser for each visitor the advertisement is shown to. Differently then in Cheap Traffic and CPC, in Cost-Per-Mill model a visitor doesn't have to click on an advertisement to be counted as a successful visitor. TV, Radio, and Newspapers use Cost-Per-Mill model for a long time. The best example of internet company who uses CPM model is YouTube. It charges per average $2 per 1000 views. In comparison, the prices of Cheap Traffic providers (for example VisitorMaker.Com) and Youtube is really similar. Both charge around $10 for 5000 visitors. The difference is that in Cheap Traffic, a website owner gets visitors interested in his products or services delivered to his site, and in CPM model, only theoretically seeing his advertisements.

Pros:

Customisable: Ads created for the advertiser with his keywords and products.
Flexibility: Traffic campaigns can be started and stopped quickly.
Control over the budget: You decide how much you want to spend.
Testing capability: You can spend minimum for testing purposes.

Cons:

Expensive: You pay for ads showed not for real visitors.
Unclear Conversion Rate: Hard to calculate how many visitors saw the ad and converted.
Ad Fraud: Fraudulent ad placer might abuse CPM model.

Cost-Per-Acquisition (CPA) vs Cheap Traffic

Cost-Per-Acquisition (CPA), also called Pay-Per-Acquisition (PPA) or Cost-Per-Action (CPA), is an online advertising pricing model where the advertiser pays website’s owner where his ad is placed for each product or service acquired. Advertiser pays only if his service or product was bought, he doesn’t pay if his ad was seen or if a visitor visited his site but did not buy anything. CPA model is very popular in affiliate marketing. It enshures advertisers that they will spend money only on real leads - leads that convert to real customers who spend money. The cost of CPA depends on a company you are doing business with. For example, Amazon pays 4% - 8% to its affiliates, depending on the amount of products or services they sell. Google though, conducts auctions where advertisers can bid for certain keywords. Differently than in PPC, in CPA Google charges certain percentage of product or service sold. In comparison to Cheap Traffic, CPA is much more expensive. CPA is good for manufacturers who can eat additional “tax” on each product sold with help of CPA.

Pros:

Advertiser pays only if product sells: No payment is due if no product is sold.
Customisable: Ads created for the advertiser with his keywords and products.

Cons:

Expensive: You pay for each conversion.

Cost-Per-Engagement (CPE) vs Cheap Traffic

Cost-Per-Engagement (CPE) is an online advertising pricing model where the advertiser pays website’s owner where his ad is placed for advertisement if a visitor somehow engages with that ad. CPE is very similar to CPM. The only difference is that in CPM an advertiser is charged for display of an advertisement and in CPE a visitor has to show that he or she noticed the advertisement. An example of CPE is a Lightbox ad. Differently than cheap traffic, in CPE a visitor is not directed to advertisers website.

Pros:

Customisable: Ads created for the advertiser with his keywords and products.
Flexibility: Traffic campaigns can be started and stopped quickly.
Control over the budget: You decide how much you want to spend.
Testing capability: You can spend minimum for testing purposes.

Cons:

Expensive: You pay for ads showed not for real visitors.
Ad Fraud: Fraudulent ad placer might abuse CPE model.

Cost-Per-View (CPV) vs Cheap Traffic

Cost-Per-View (CPV), also called Pay-Per-Video-View (PPVV), is an online advertising pricing model where an advertiser pays for number of views his advertisement receives. CPV is a version of CPM where the only difference is that in CPV an advertisement is shown in video format. Also, usually in CPV ad gets more visitor engagement than in CPM. For example, in Google’s AdWords, an advertiser is charged for an ad if a viewer watches his or her ad for at least 30 seconds or clicks on it. The most famous Cost-Per-View advertiser is YouTube. YouTube uses two ways to place ads:
In-Display - ads presented next to videos on YouTube. A visitor can ignore them and go straight to requested video.
In-Stream - ads presented in the beginning, in the middle, or at the end of video requested. In-Stream ads have to be watched from 5 seconds to entire ad length depending of YouTube algorithm and cannot be skipped entirely.

Pros:

Customisable: Ads created for the advertiser with his keywords and products.
Flexibility: Traffic campaigns can be started and stopped quickly.
Control over the budget: You decide how much you want to spend.
Testing capability: You can spend minimum for testing purposes.

Cons:

Expensive: You pay for ads showed not for real visitors.
Bidding wars: If several websites want the same keyword, ad prices rise.
Questionable targeting: Ad might be not be relevant to visitor.
Ad Fraud: Fraudulent ad placer might abuse CPE model.

Cost-Per-Install (CPI) vs Cheap Traffic

Cost-Per-Install (CPI) is an online advertising pricing model specific to mobile applications. In CPI an advertiser pays for each application installed. There is no charge if a visitor sees an application or engages it. The advertiser is charged only if the application is installed on visitors device.

Conclusion

This article explains what is the cheap traffic and compares it to other online advertising models, such as Cost-Per-Click, Cost-Per-Mill, Cost-Per-Acquisition, Cost-Per-Engagement, Cost-Per-View, and Cost-Per-Install. Although, each model has it unique strengths and weaknesses, in most cases cheap traffic wins in terms of price and effectiveness to advertiser.

About the Author

Connect with me: