Forem: Manikanta Yarramsetti

JavaScript Promises Explained With Simple Real Examples

Manikanta Yarramsetti — Tue, 17 Mar 2026 06:58:22 +0000

Promises confused me for a long time.

I kept reading definitions like "a promise is an object that represents
the eventual completion or failure of an async operation" and I just
stared at the screen.

So let me explain it the way I wish someone explained it to me.

What is a Promise in simple words

Think about ordering food at a restaurant.

You order, the waiter says okay and walks away. You don't sit there
frozen waiting. You talk to your friends, drink water, do other things.

When the food is ready the waiter comes back either with your food
or says sorry we ran out of that.

That is a Promise. You asked for something. It is being worked on.
Either it succeeds or it fails. Meanwhile everything else keeps going.

How it looks in code

const myPromise = new Promise(function(resolve, reject) {

  let success = true;

  if (success) {
    resolve("it worked");
  } else {
    reject("something went wrong");
  }

});

resolve means it went well.
reject means something failed.

How to use the result

myPromise
  .then(function(result) {
    console.log(result); // "it worked"
  })
  .catch(function(error) {
    console.log(error); // "something went wrong"
  });

.then runs when the promise resolves.
.catch runs when the promise rejects.

Simple as that.

A real example — fetching data

This is where you will actually use promises every day.

fetch("https://jsonplaceholder.typicode.com/users/1")
  .then(function(response) {
    return response.json();
  })
  .then(function(data) {
    console.log(data.name);
  })
  .catch(function(error) {
    console.log("error happened:", error);
  });

fetch returns a Promise. When the data comes back .then runs.
If something fails .catch handles it.

You will write this pattern a lot.

Three states of a Promise

A Promise is always in one of these three states:

Pending — still waiting, not done yet

Fulfilled — it worked, resolve was called

Rejected — it failed, reject was called

Once a Promise is fulfilled or rejected it does not change.
It stays that way.

async and await — cleaner way to write the same thing

Instead of chaining .then and .catch you can use async await.
It is the same thing just easier to read.

async function getUser() {
  try {
    const response = await fetch("https://jsonplaceholder.typicode.com/users/1");
    const data = await response.json();
    console.log(data.name);
  } catch (error) {
    console.log("something went wrong:", error);
  }
}

getUser();

await tells JavaScript to wait for the Promise to finish before
moving to the next line. But only inside an async function.

try catch is the async await version of .then and .catch.

Both do the exact same thing. Most people prefer async await because
it reads like normal code.

Promise.all — when you need multiple things at once

Sometimes you need to fetch two or three things at the same time
and wait for all of them to finish.

const promise1 = fetch("https://jsonplaceholder.typicode.com/users/1");
const promise2 = fetch("https://jsonplaceholder.typicode.com/users/2");
const promise3 = fetch("https://jsonplaceholder.typicode.com/users/3");

Promise.all([promise1, promise2, promise3])
  .then(function(results) {
    console.log("all three done", results);
  })
  .catch(function(error) {
    console.log("one of them failed:", error);
  });

All three run at the same time. When all finish .then runs.
If even one fails .catch runs.

Much faster than doing them one by one.

A small complete example

<!DOCTYPE html>
<html>
<body>

  <button id="loadBtn">Load User</button>
  <p id="result">click the button</p>

  <script>
    const btn = document.getElementById("loadBtn");
    const result = document.getElementById("result");

    btn.addEventListener("click", async function() {
      result.textContent = "loading...";

      try {
        const response = await fetch(
          "https://jsonplaceholder.typicode.com/users/1"
        );
        const data = await response.json();
        result.textContent = "Name: " + data.name;
      } catch (error) {
        result.textContent = "something went wrong";
      }
    });
  </script>

</body>
</html>

Click the button. It fetches a user from an API and shows the name.
Real async code working in the browser.

That is it honestly

Promises sound scary but the idea is simple. You ask for something,
you wait, either you get it or something goes wrong.

Start with fetch and async await. That is what you will use 90 percent
of the time anyway.

JavaScript Events Simply Explained With Real Code Examples

Manikanta Yarramsetti — Tue, 17 Mar 2026 06:46:48 +0000

I remember when I started JavaScript, events confused me a lot.

Not because they are hard. Just because nobody explained it simply.

So let me try.

Okay so what is an event

An event is just something the user does on your page.

Clicked a button. Typed in a box. Pressed a key. Submitted a form.
Scrolled down. All of these are events.

JavaScript lets you watch for these things and do something when
they happen. That is the whole idea.

The basic way to listen

const btn = document.getElementById("myBtn");

btn.addEventListener("click", function() {
  console.log("someone clicked the button");
});

Three things here. The element. The event name. The function to run.

That is the pattern you will use everywhere.

There is also an event object

When something happens the browser gives you an object with all
the details about it. Most people call it e or event.

btn.addEventListener("click", function(e) {
  console.log(e.target);  // what got clicked
  console.log(e.type);    // "click"
});

You do not always need it but it is always there if you want it.

Events you will use all the time

click — someone clicks something

btn.addEventListener("click", function() {
  console.log("clicked");
});

input — someone is typing in a field

const box = document.getElementById("searchBox");

box.addEventListener("input", function(e) {
  console.log(e.target.value);
});

This fires every time they type a character. Really useful for
live search or character counters.

submit — someone submits a form

const form = document.getElementById("myForm");

form.addEventListener("submit", function(e) {
  e.preventDefault();
  console.log("form submitted");
});

The e.preventDefault() stops the page from refreshing.
You almost always need this on forms.

keydown — someone presses a key

document.addEventListener("keydown", function(e) {
  if (e.key === "Enter") {
    console.log("enter was pressed");
  }
});

mouseover — someone hovers over an element

const card = document.getElementById("card");

card.addEventListener("mouseover", function() {
  card.style.background = "lightblue";
});

What is preventDefault

When you submit a form the browser reloads the page by default.
When you click a link it goes somewhere by default.

preventDefault stops that from happening so you can handle it
yourself with JavaScript.

link.addEventListener("click", function(e) {
  e.preventDefault();
  console.log("stopped the link from going anywhere");
});

You will use this a lot.

Event bubbling

This one is a bit different but worth knowing.

Say you have a button inside a div. You click the button.
The click fires on the button first then travels up to the div
then to the body and keeps going up.

document.getElementById("myDiv").addEventListener("click", function() {
  console.log("div clicked");
});

document.getElementById("myBtn").addEventListener("click", function() {
  console.log("button clicked");
});

// click the button and you see both
// button clicked
// div clicked

If you want to stop it going up just use stopPropagation.

btn.addEventListener("click", function(e) {
  e.stopPropagation();
  console.log("stays here, does not go up");
});

A real small example

Let me put it all together in something you can actually run.

<!DOCTYPE html>
<html>
<body>

  <input id="nameInput" placeholder="type your name" />
  <button id="greetBtn">Say Hello</button>
  <p id="result"></p>

  <script>
    const input = document.getElementById("nameInput");
    const btn = document.getElementById("greetBtn");
    const result = document.getElementById("result");

    btn.addEventListener("click", function() {
      const name = input.value.trim();

      if (name === "") {
        result.textContent = "type your name first";
        return;
      }

      result.textContent = "hello " + name + "!";
    });

    input.addEventListener("keydown", function(e) {
      if (e.key === "Enter") {
        btn.click();
      }
    });
  </script>

</body>
</html>

Type a name, click the button or just press Enter.
Both work because we listened for two different events.

Honestly that is all you need to start

Click, input, submit, keydown. Learn these four first.

Everything else like drag events, touch events, scroll events,
they all follow the exact same pattern. Once you get the idea
the rest is easy to pick up.

Just start building small things and you will get it fast.

Debugging Java in IntelliJ

Manikanta Yarramsetti — Mon, 09 Mar 2026 17:18:12 +0000

Step 1 — Set a breakpoint

Click on the line number in your code. A red dot appears. That is your
breakpoint. The code will stop right there when you run it.

Step 2 — Run in debug mode

Don't click the green play button. Click the bug icon next to it instead.
Or right click near your main method and select Debug.

Now when your code hits the breakpoint it stops and you can see everything.

Step 3 — Look at your variables

This is the best part. At the bottom you get a panel showing all your
variables and their current values at that exact moment.

No more guessing. You just see it.

Moving through the code

Once it stops you have a few buttons to move through the code:

F8 — Step Over
Goes to the next line. Does not go inside any method. I use this one most.

F7 — Step Into
Goes inside the method on that line. Use this when you want to see what
is happening inside a method.

Shift F8 — Step Out
You went inside a method and now want to come back out. This does that.

F9 — Resume
Continue running until the next breakpoint.

Conditional breakpoints — big time saver

Got a loop running 500 times and the bug only happens at index 200?
You don't want to press F9 two hundred times.

Right click the red dot and you will see a condition field. Type something
like i == 200 and it only stops when that is true.

Evaluate Expression

Press Alt + F8 while debugging. A small window opens where you can
type any Java expression and run it right there on the spot.

Want to check what a method returns with a specific value? Just type
it and see. No need to change code and restart.

Quick example

Say something is wrong with this:

public int getTotal(List<Integer> numbers) {
    int total = 0;
    for (int num : numbers) {
        total += num;
    }
    return total;
}

Put a breakpoint inside the loop. Run debug mode. Press F8 each step
and watch total and num change in the variables panel. You will
immediately see which iteration is wrong.

No println needed.

That is it

Start with just a breakpoint and F8. Get comfortable. Then slowly
try the rest.

Once it clicks you will never go back to println debugging. It is
just so much faster and clearer.

Terraform Saved Me Hours Every Week — Here's What It Actually Does

Manikanta Yarramsetti — Sun, 08 Mar 2026 05:51:37 +0000

Before Terraform, my routine was open AWS console, click here, create EC2,
set up security groups, configure VPC… and if something breaks, do it all
over again. It was really painful.

Someone in my team said "just use Terraform bro." I ignored it for weeks.
Big mistake.

So what is Terraform?

It is an Infrastructure as Code tool. Sounds fancy but basically you write
what you want in a .tf file, run a few commands, and your entire cloud
setup is ready. That's it.

What I liked about it

Write once and use anywhere. Same config works on AWS, Azure, GCP. No
rewriting everything again and again.

It remembers what it created. Terraform keeps a state file so it knows
what already exists and won't create duplicates. Pretty smart honestly.

Team friendly too. Just push your .tf files to Git and your whole team
knows what's going on. No more "who created that EC2 and why."

The commands I use daily

terraform init     
terraform plan     
terraform apply

init sets everything up, plan shows what will be created, apply actually
creates it. That's all you need to get started.

Quick example

Want to create an EC2 on AWS? This is all you write:

provider "aws" {
  region = "us-east-1"
}

resource "aws_instance" "my_server" {
  ami           = "ami-0c55b159cbfafe1f0"
  instance_type = "t3.micro"

  tags = {
    Name = "MyFirstServer"
  }
}

Run terraform apply and your server is live. No console, no clicking around.

The honest downsides

The state file can cause problems when working in a team. Best to store it
in S3. Also the learning curve is real, you need to understand cloud basics
first. And everything is code, there is no GUI at all.

That's it

Once it clicks you won't go back to the AWS console. Your infrastructure
becomes code you can version, share and reuse.

If you haven't tried it just start with something small today. You'll
get it faster than you think.

Java Array Methods That Actually Make Sense

Manikanta Yarramsetti — Wed, 04 Mar 2026 09:03:59 +0000

Arrays were honestly confusing to me at first. Not the concept — storing multiple values, fine. But all the utility methods scattered across different classes? That took a while to click.

Here's what I wish someone had just shown me early on.

First, the Two Classes You Need to Know

Most array utility methods live in java.util.Arrays — you need to import it.

For resizing and dynamic stuff, ArrayList is your friend (but that's a separate topic).

import java.util.Arrays;

Okay, let's get into it.

The Methods

Arrays.sort() — sorts your array in ascending order. Works for numbers and strings.

int[] nums = {5, 2, 8, 1, 9};
Arrays.sort(nums);
// nums is now {1, 2, 5, 8, 9}

Arrays.toString() — this one you'll use constantly for debugging. Prints array contents instead of some weird memory address.

int[] nums = {1, 2, 3};
System.out.println(nums);              // [I@6d06d69c  ← useless
System.out.println(Arrays.toString(nums)); // [1, 2, 3]  ← useful

Arrays.fill() — fills all elements with a single value. Handy for initialization.

int[] grid = new int[5];
Arrays.fill(grid, 0);
// {0, 0, 0, 0, 0}

Arrays.copyOf() — copies an array into a new one. You can also resize it while copying.

int[] original = {1, 2, 3, 4, 5};
int[] copy = Arrays.copyOf(original, 3);
// copy = {1, 2, 3}

Arrays.copyOfRange() — copies a specific slice of the array.

int[] nums = {10, 20, 30, 40, 50};
int[] slice = Arrays.copyOfRange(nums, 1, 4);
// slice = {20, 30, 40}

Arrays.equals() — checks if two arrays have the same values in the same order.

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};

System.out.println(a == b);             // false (different objects)
System.out.println(Arrays.equals(a, b)); // true ✅

Same lesson as strings — never use == to compare arrays.

Arrays.binarySearch() — searches for a value and returns its index. Sort the array first, otherwise results are unpredictable.

int[] nums = {1, 3, 5, 7, 9};
int index = Arrays.binarySearch(nums, 5);
// index = 2

array.length — not a method, it's a property. But you'll use it everywhere.

int[] nums = {4, 8, 15, 16, 23};
System.out.println(nums.length); // 5

No parentheses — just .length, not .length(). That trips up a lot of beginners.

Quick Reference

Method	What it does
`Arrays.sort()`	Sort ascending
`Arrays.toString()`	Print readable format
`Arrays.fill()`	Set all values
`Arrays.copyOf()`	Copy (with resize option)
`Arrays.copyOfRange()`	Copy a slice
`Arrays.equals()`	Compare two arrays
`Arrays.binarySearch()`	Find index of a value
`.length`	Get array size

One Thing to Remember

Arrays in Java have a fixed size — once created, you can't add or remove elements. If you need a resizable list, use ArrayList.

// Fixed size — can't grow
int[] arr = new int[5];

// Flexible — can add/remove
ArrayList<Integer> list = new ArrayList<>();

That's a whole other post though. 😄

Got questions or want me to cover ArrayList next? Drop a comment below!

Happy coding 🙌

Java String Methods You'll Actually Use Every Day

Manikanta Yarramsetti — Wed, 04 Mar 2026 08:52:37 +0000

I remember when I first started learning Java, strings felt weirdly complicated. Like, why so many methods? Which ones do I even need?

Turns out, you only need a handful 90% of the time. Here they are.

The Ones That Matter

length() — gives you the number of characters.

String name = "Ravi";
System.out.println(name.length()); // 4

toUpperCase() / toLowerCase() — case conversion, simple as that.

String city = "chennai";
System.out.println(city.toUpperCase()); // CHENNAI

trim() — removes extra spaces from both ends. Super useful when handling user input.

String input = "  hello  ";
System.out.println(input.trim()); // "hello"

contains() — checks if a string has a certain word or character inside it.

String msg = "Java is fun";
System.out.println(msg.contains("fun")); // true

replace() — swap out characters or words.

String s = "I like cats";
System.out.println(s.replace("cats", "dogs")); // I like dogs

substring() — grab a piece of the string by index.

String word = "Developer";
System.out.println(word.substring(0, 3)); // Dev

equals() vs == — this one trips up beginners a lot.

String a = "hello";
String b = "hello";

System.out.println(a == b);        // might be true (but don't rely on it)
System.out.println(a.equals(b));   // always true ✅

Always use .equals() when comparing strings. == compares references, not content.

split() — break a string into an array based on a separator.

String fruits = "apple,mango,banana";
String[] list = fruits.split(",");
// list[0] = "apple", list[1] = "mango", list[2] = "banana"

Quick Recap

Method	What it does
`length()`	Count characters
`toUpperCase()`	All caps
`trim()`	Remove edge spaces
`contains()`	Check if something's inside
`replace()`	Swap text
`substring()`	Slice it
`equals()`	Safe string comparison
`split()`	Break into array

That's it. Learn these 8 and you're good for most beginner-to-intermediate Java work.

Strings in Java are immutable by the way — every method returns a new string, it doesn't change the original. Worth keeping that in mind.

Drop a comment if you want me to cover StringBuilder next — it's great when you're doing a lot of string manipulation in loops.

Happy coding 🙌

RAG AI

Manikanta Yarramsetti — Mon, 12 Jan 2026 08:25:19 +0000

What is RAG?

RAG stands for Retrieval Augmented Generation. It combines AI language models with your own documents to provide accurate, up-to-date answers based on your specific information.

How RAG Works

Your question is converted into searchable format. System searches your documents for relevant information. AI reads the found information. AI generates answer using both its knowledge and your data. Think of it like giving AI access to your personal library before answering questions.

Why Use RAG?

Provides accurate answers from your own data. Reduces AI hallucinations and errors. Works with current data, not just old training data. Maintains data privacy and security. Easy to update without retraining models.

Common Use Cases

Customer Support: Answer questions using company knowledge base
Internal Search: Find information across company documents
Legal Research: Search contracts and legal documents quickly
Healthcare: Access patient records and medical research safely
Education: Create personalized learning from course materials

RAG vs Regular AI

Regular AI only knows training data and may give wrong answers. RAG AI searches your documents first then generates accurate answers with sources.

Simple Example

Without RAG: "I do not know your company vacation policy"
With RAG: "According to your employee handbook, you get 15 days paid vacation annually"

Key Components

Vector Database: Stores documents in searchable format (Pinecone, ChromaDB)
Embeddings: Converts text to searchable numbers
Language Model: Generates answers (GPT-4, Claude)
Retrieval System: Finds relevant information from your data

Benefits and Limitations

Benefits: More accurate, shows sources, easy updates, works with private data
Limitations: Depends on document quality, needs proper setup, may miss poorly indexed info

Getting Started

Choose a vector database. Prepare and clean your documents. Set up embedding pipeline. Connect to AI language model. Test with sample questions. Iterate and improve.

Key Takeaways

RAG combines AI with your own data for better answers. More accurate than regular AI alone. Easy to update without retraining. Perfect for company-specific information. Shows sources for transparency.

Generative AI

Manikanta Yarramsetti — Mon, 12 Jan 2026 08:23:29 +0000

What is Generative AI?

Generative AI is artificial intelligence that creates new content like text, images, code, music, and videos. Instead of just analyzing data, it generates original content based on patterns it has learned.

Popular Types

Text Generation: ChatGPT, Claude, Gemini - Write articles, emails, and code
Image Generation: DALL-E, Midjourney - Create pictures from text descriptions
Code Generation: GitHub Copilot - Write programming code automatically
Audio/Video: Create music, voice, and videos from text prompts

Real-World Uses

Content creation for blogs and marketing. Software development and debugging. Customer service chatbots. Design and artwork generation. Personalized education and tutoring. Medical image analysis and research.

Benefits

Saves time on repetitive tasks. Boosts creativity with new ideas. Works 24/7 without breaks. Scales easily for any workload. Reduces content creation costs.

Limitations

Can generate incorrect information. May reflect biases from training data. Requires human review for accuracy. Cannot truly understand context like humans.

Using Gen AI Responsibly

Always verify important information. Do not share sensitive data. Give credit when using AI content. Use it to assist, not replace human judgment. Be transparent about AI usage.

Simple Example

Prompt: "Write a professional email about a project delay"

AI creates a polite, clear email explaining the situation professionally in seconds.

Tips for Better Results

Be specific in your requests. Provide context and examples. Break complex tasks into steps. Review and edit AI outputs. Combine AI suggestions with your expertise.

Key Takeaways

Generative AI creates new content from learned patterns. It saves time and boosts creativity. Always verify AI-generated content. Use it responsibly and ethically. It is a tool to assist, not replace humans.

Understanding Okta Tokens

Manikanta Yarramsetti — Mon, 12 Jan 2026 08:20:17 +0000

What are Okta Tokens?

Okta tokens are digital credentials that prove your identity when accessing applications. Think of them like a secure badge that shows who you are and what you can access, without needing to show your password every time.

Three Types of Tokens

Access Token

Used to access APIs and protected resources. Valid for 1 hour by default.

ID Token

Contains your basic profile information like name and email.

Refresh Token

Used to get new access tokens without logging in again. Valid for 90 days.

Token Structure

Tokens use JWT format with three parts:

header.payload.signature

Example:

eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIn0.Signature

Quick Setup in Spring Boot

Add dependency:

<dependency>
    <groupId>com.okta.spring</groupId>
    <artifactId>okta-spring-boot-starter</artifactId>
    <version>3.0.5</version>
</dependency>

Configure in application.properties:

okta.oauth2.issuer=https://your-domain.okta.com/oauth2/default
okta.oauth2.client-id=your-client-id
okta.oauth2.client-secret=your-client-secret

Secure Your APIs

Basic security configuration:

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/public/**").permitAll()
                .anyRequest().authenticated()
            )
            .oauth2ResourceServer(oauth2 -> oauth2.jwt());
        return http.build();
    }
}

Get User Information from Token

@RestController
@RequestMapping("/api")
public class UserController {

    @GetMapping("/user")
    public Map<String, Object> getUserInfo(@AuthenticationPrincipal Jwt jwt) {
        Map<String, Object> info = new HashMap<>();
        info.put("userId", jwt.getSubject());
        info.put("email", jwt.getClaim("email"));
        info.put("name", jwt.getClaim("name"));
        return info;
    }
}

Protect Endpoints by Role

@RestController
@RequestMapping("/api/admin")
public class AdminController {

    @GetMapping("/dashboard")
    @PreAuthorize("hasAuthority('SCOPE_admin')")
    public String adminDashboard() {
        return "Admin Dashboard Data";
    }
}

Common Token Claims

Claim	What It Contains
sub	User ID
email	User email
name	User full name
exp	When token expires
iss	Who issued the token
groups	User roles

Token Lifetimes

Token Type	How Long It Lasts
Access Token	1 hour
ID Token	1 hour
Refresh Token	90 days

Check Token Expiration

@GetMapping("/token-status")
public String checkToken(@AuthenticationPrincipal Jwt jwt) {
    long secondsLeft = Duration.between(
        Instant.now(), 
        jwt.getExpiresAt()
    ).getSeconds();

    return "Token expires in " + secondsLeft + " seconds";
}

Handle Token Errors

@ControllerAdvice
public class TokenErrorHandler {

    @ExceptionHandler(JwtException.class)
    public ResponseEntity<String> handleInvalidToken(JwtException ex) {
        return ResponseEntity
            .status(HttpStatus.UNAUTHORIZED)
            .body("Invalid or expired token");
    }
}

Best Practices

Always use HTTPS. Never store tokens in localStorage, use httpOnly cookies instead. Validate tokens on every API request. Refresh tokens before they expire. Use appropriate scopes for different user roles. Log token errors for security monitoring.

Quick Summary

Okta tokens are secure credentials that authenticate users. Access tokens let you call APIs. ID tokens give you user info. Refresh tokens get new access tokens. Spring Boot makes it easy to use Okta tokens with just a few lines of configuration.

When Token Expires

When an access token expires, use the refresh token to get a new one automatically. This keeps users logged in without asking for their password again.

Testing Your Setup

Test protected endpoint:

curl -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     http://localhost:8080/api/user

Liquibase in Spring Boot

Manikanta Yarramsetti — Mon, 12 Jan 2026 08:16:23 +0000

What is Liquibase?

Liquibase is a database schema change management tool that tracks, versions, and deploys database changes. It supports multiple databases and file formats including XML, YAML, JSON, and SQL.

Quick Setup

Add dependency to pom.xml:

<dependency>
    <groupId>org.liquibase</groupId>
    <artifactId>liquibase-core</artifactId>
</dependency>

Configure in application.properties:

spring.liquibase.enabled=true
spring.liquibase.change-log=classpath:db/changelog/db.changelog-master.yaml
spring.liquibase.contexts=dev,prod

Project Structure

src/main/resources/
  db/
    changelog/
      db.changelog-master.yaml
      changes/
        001-create-users.yaml
        002-add-email-column.yaml

Master Changelog

db.changelog-master.yaml:

databaseChangeLog:
  - include:
      file: db/changelog/changes/001-create-users.yaml
  - include:
      file: db/changelog/changes/002-add-email-column.yaml

Creating Tables

001-create-users.yaml:

databaseChangeLog:
  - changeSet:
      id: 001
      author: developer
      changes:
        - createTable:
            tableName: users
            columns:
              - column:
                  name: id
                  type: BIGINT
                  autoIncrement: true
                  constraints:
                    primaryKey: true
              - column:
                  name: username
                  type: VARCHAR(50)
                  constraints:
                    nullable: false
                    unique: true
              - column:
                  name: created_at
                  type: TIMESTAMP
                  defaultValueComputed: CURRENT_TIMESTAMP

Adding Columns

002-add-email-column.yaml:

databaseChangeLog:
  - changeSet:
      id: 002
      author: developer
      changes:
        - addColumn:
            tableName: users
            columns:
              - column:
                  name: email
                  type: VARCHAR(100)
                  constraints:
                    nullable: false
                    unique: true

Creating Foreign Keys

003-create-orders.yaml:

databaseChangeLog:
  - changeSet:
      id: 003
      author: developer
      changes:
        - createTable:
            tableName: orders
            columns:
              - column:
                  name: id
                  type: BIGINT
                  autoIncrement: true
                  constraints:
                    primaryKey: true
              - column:
                  name: user_id
                  type: BIGINT
              - column:
                  name: total
                  type: DECIMAL(10,2)
        - addForeignKeyConstraint:
            baseTableName: orders
            baseColumnNames: user_id
            referencedTableName: users
            referencedColumnNames: id
            constraintName: fk_orders_user

Rollback Support

Define rollback for each change:

databaseChangeLog:
  - changeSet:
      id: 004
      author: developer
      changes:
        - addColumn:
            tableName: users
            columns:
              - column:
                  name: phone
                  type: VARCHAR(20)
      rollback:
        - dropColumn:
            tableName: users
            columnName: phone

Using Contexts

Different changes for different environments:

databaseChangeLog:
  - changeSet:
      id: 005
      author: developer
      context: dev
      changes:
        - insert:
            tableName: users
            columns:
              - column:
                  name: username
                  value: test_user
              - column:
                  name: email
                  value: test@example.com

Preconditions

Add safety checks before execution:

databaseChangeLog:
  - changeSet:
      id: 006
      author: developer
      preConditions:
        - not:
            - columnExists:
                tableName: users
                columnName: status
      changes:
        - addColumn:
            tableName: users
            columns:
              - column:
                  name: status
                  type: VARCHAR(20)

Using SQL Files

For complex migrations:

databaseChangeLog:
  - changeSet:
      id: 007
      author: developer
      changes:
        - sqlFile:
            path: db/changelog/sql/007-migration.sql

007-migration.sql:

-- liquibase formatted sql

-- changeset developer:007
UPDATE users SET status = 'ACTIVE' WHERE status IS NULL;
CREATE INDEX idx_users_status ON users(status);

-- rollback DROP INDEX idx_users_status;
-- rollback UPDATE users SET status = NULL WHERE status = 'ACTIVE';

Data Migration

Update existing data:

databaseChangeLog:
  - changeSet:
      id: 008
      author: developer
      changes:
        - update:
            tableName: users
            columns:
              - column:
                  name: status
                  value: LEGACY
            where: created_at < '2020-01-01'

Load Data from CSV

databaseChangeLog:
  - changeSet:
      id: 009
      author: developer
      changes:
        - loadData:
            tableName: categories
            file: db/data/categories.csv
            columns:
              - column:
                  name: name
                  type: STRING
              - column:
                  name: description
                  type: STRING

Creating Indexes

databaseChangeLog:
  - changeSet:
      id: 010
      author: developer
      changes:
        - createIndex:
            indexName: idx_username
            tableName: users
            columns:
              - column:
                  name: username

Common Change Types

Change Type	Purpose
createTable	Create new table
dropTable	Remove table
addColumn	Add column
dropColumn	Remove column
modifyDataType	Change column type
renameColumn	Rename column
createIndex	Add index
addForeignKeyConstraint	Add foreign key
insert	Insert data
update	Update data
sql	Execute custom SQL

Programmatic Configuration

@Configuration
public class LiquibaseConfig {

    @Bean
    public SpringLiquibase liquibase(DataSource dataSource) {
        SpringLiquibase liquibase = new SpringLiquibase();
        liquibase.setDataSource(dataSource);
        liquibase.setChangeLog("classpath:db/changelog/db.changelog-master.yaml");
        liquibase.setContexts("dev,prod");
        return liquibase;
    }
}

Best Practices

Never modify executed changesets. Use meaningful changeset IDs like 001, 002 or dates. Include author in every changeset. Use contexts for environment-specific changes. Always define rollback for production. Test migrations in development first. Keep changesets small and focused. Add preconditions to prevent errors. Document complex migrations with comments.

Troubleshooting

Clear checksums after manual fixes:

-- View changelog table
SELECT * FROM databasechangelog;

-- Clear checksums
UPDATE databasechangelog SET md5sum = NULL;

Mark changeset as executed manually:

INSERT INTO databasechangelog (ID, AUTHOR, FILENAME, DATEEXECUTED, ORDEREXECUTED, EXECTYPE)
VALUES ('011', 'developer', 'changelog.yaml', NOW(), 11, 'EXECUTED');

Liquibase vs Flyway

Feature	Liquibase	Flyway
File Formats	XML, YAML, JSON, SQL	SQL primarily
Rollback	Built-in	Paid feature
Database Agnostic	Excellent	Good
Learning Curve	Moderate	Easy
Preconditions	Yes	No

When to Use Liquibase

Choose Liquibase when you need database portability across MySQL, PostgreSQL, Oracle. Need built-in rollback capabilities. Want to use YAML or XML instead of SQL. Require conditional migrations with contexts. Need preconditions for safety checks. Working on complex enterprise applications.

Database Migration Scripts in Spring Boot

Manikanta Yarramsetti — Mon, 12 Jan 2026 08:13:20 +0000

What Are Database Migrations?

Database migrations are version-controlled scripts that manage schema changes in your Spring Boot application. They ensure your database structure stays consistent across all environments.

Why Use Migrations?

Track database changes alongside code. Automate schema updates during deployment. Enable rollback when things go wrong. Prevent conflicts in team environments.

Two Popular Tools

Flyway: Simple and SQL-First

Setup:

<dependency>
    <groupId>org.flywaydb</groupId>
    <artifactId>flyway-core</artifactId>
</dependency>

Configuration in application.properties:

spring.flyway.enabled=true
spring.flyway.locations=classpath:db/migration

Migration Files in src/main/resources/db/migration:

V1__Create_users_table.sql

CREATE TABLE users (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    username VARCHAR(50) NOT NULL,
    email VARCHAR(100) NOT NULL
);

V2__Add_status_column.sql

ALTER TABLE users ADD COLUMN status VARCHAR(20) DEFAULT 'ACTIVE';

Naming Pattern: V{version}__{description}.sql

Liquibase: Flexible and Database-Agnostic

Setup:

<dependency>
    <groupId>org.liquibase</groupId>
    <artifactId>liquibase-core</artifactId>
</dependency>

Configuration:

spring.liquibase.enabled=true
spring.liquibase.change-log=classpath:db/changelog/db.changelog-master.yaml

Master Changelog in db.changelog-master.yaml:

databaseChangeLog:
  - include:
      file: db/changelog/v1-create-users.yaml
  - include:
      file: db/changelog/v2-add-status.yaml

Changeset in v1-create-users.yaml:

databaseChangeLog:
  - changeSet:
      id: 1
      author: developer
      changes:
        - createTable:
            tableName: users
            columns:
              - column:
                  name: id
                  type: BIGINT
                  autoIncrement: true
                  constraints:
                    primaryKey: true
              - column:
                  name: username
                  type: VARCHAR(50)
              - column:
                  name: email
                  type: VARCHAR(100)

Quick Comparison

Feature	Flyway	Liquibase
Learning Curve	Easy	Moderate
File Format	SQL	SQL, YAML, XML, JSON
Rollback	Paid	Built-in
Best For	Simple projects	Complex/multi-DB projects

Essential Best Practices

Never modify executed migrations - Create new ones instead
Use descriptive names - V3__Add_user_authentication_tables.sql
Test in dev first - Always validate before production
Keep migrations small - One logical change per migration
Add comments - Document why, not just what

Example: Adding a New Feature

Flyway Approach:

-- V5__Add_user_profiles.sql
CREATE TABLE user_profiles (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    user_id BIGINT NOT NULL,
    bio TEXT,
    FOREIGN KEY (user_id) REFERENCES users(id)
);

Liquibase Approach:

databaseChangeLog:
  - changeSet:
      id: 5
      author: developer
      changes:
        - createTable:
            tableName: user_profiles
            columns:
              - column:
                  name: id
                  type: BIGINT
                  autoIncrement: true
                  constraints:
                    primaryKey: true
              - column:
                  name: user_id
                  type: BIGINT
              - column:
                  name: bio
                  type: TEXT
        - addForeignKeyConstraint:
            baseTableName: user_profiles
            baseColumnNames: user_id
            referencedTableName: users
            referencedColumnNames: id

When Migrations Run

Spring Boot automatically runs pending migrations on application startup. The tools track executed migrations in dedicated database tables:

Flyway: flyway_schema_history
Liquibase: databasechangelog

Troubleshooting Tip

If a migration fails, both tools mark it as failed. Fix the issue, then:

Flyway:

flyway.repair()

Or delete the failed record manually

Liquibase:

liquibase.clearCheckSums()

Or manually update the status in the changelog table

Choosing Your Tool

Choose Flyway if you:

Prefer writing SQL directly
Want simplicity and minimal configuration
Have a single database type

Choose Liquibase if you:

Need database portability between MySQL, PostgreSQL, etc.
Want advanced features like contexts and labels
Need built-in rollback capabilities

Both integrate seamlessly with Spring Boot and get the job done reliably!

Essential Git Commands You Should Know

Manikanta Yarramsetti — Sun, 11 Jan 2026 17:21:55 +0000

Git is the most popular version control system used by developers. Whether you’re new or need a quick refresher, here are the fundamental Git commands to boost your productivity.

1. Check Git Version

Verify the installed Git version:

git --version

2. Configure Git (Username & Email)

Set your user name and email for commits:

git config --global user.name "Your Name"
git config --global user.email "Your Mail"

3. Initialize a New Git Repository

Create a new Git repo in your current folder:

git init

4. Clone a Remote Repository

Download a remote repo to your machine:

git clone https://github.com/user/repo.git

5. Check Repository Status

See changed files and staging status:

git status

6. Stage Files for Commit

Add a specific file to staging area:

git add <filename>

Add all changes:

git add .

7. Commit Changes

Commit staged files with a message:

git commit -m "Your descriptive commit message"

8. View Commit History

Show commit logs:

git log

9. Create a New Branch

Create a branch named feature-branch:

git branch feature-branch

10. Switch to a Branch

Switch to the branch:

git checkout feature-branch

Or create & switch in one command (Git 2.23+):

git switch -c feature-branch

11. Merge Branches

Merge feature-branch into current branch:

git merge feature-branch

12. Push Changes to Remote

Push your commits to the remote repository:

git push origin <branch-name>

13. Pull Latest Changes from Remote

Fetch and merge changes from remote:

git pull origin <branch-name>

14. Delete a Branch

Delete a local branch:

git branch -d <branch-name>

15. Undo Last Commit (Keep Changes)

Undo last commit but keep changes staged:

git reset --soft HEAD~1