Forem: Kanishka L

AWS Service Blog: AWS Step Functions

Kanishka L — Thu, 18 Dec 2025 16:17:10 +0000

Service Overview

AWS Step Functions is a serverless workflow orchestration service that helps developers coordinate multiple AWS services into automated workflows. It allows you to design complex processes using visual state machines, making application logic easier to build, manage, and debug.

Key Features

Visual Workflow Designer – Create workflows using state diagrams

Service Integration – Works with Lambda, ECS, EC2, DynamoDB, SNS, and more

Error Handling & Retry Logic – Built-in failure management

Serverless Architecture – No infrastructure to manage

Long-Running Workflows – Supports workflows running for days or months

Monitoring & Logging – Integrated with Amazon CloudWatch

AWS Category / Cloud Domain

Category: Application Integration

Cloud Domain: Serverless & Workflow Orchestration

Where It Fits in Cloud / DevOps Lifecycle

AWS Step Functions fits mainly in the orchestration and automation stage of the Cloud/DevOps lifecycle:

Automates CI/CD workflows

Coordinates microservices communication

Manages data processing pipelines

Handles business process automation

Improves reliability in production deployments

Programming Language / Access Methods

AWS Step Functions can be accessed using:

AWS Management Console (Visual Editor)

Amazon States Language (JSON-based)

AWS SDKs with languages like:

Python

Java

JavaScript

AWS CLI and CloudFormation

Pricing Model

AWS Step Functions uses a pay-per-use pricing model:

Charged based on state transitions

Two workflow types:

Standard Workflows – Pay per state transition

Express Workflows – Pay based on execution time and number of executions

Free Tier includes limited workflow executions per month

Kibana – DevSecOps Tool Overview

Kanishka L — Thu, 18 Dec 2025 16:08:55 +0000

1) Overview of the Tool

Kibana is an intuitive web-based data visualization and analytics interface that works on top of Elasticsearch data. It lets users search, explore, visualize, and build dashboards from large datasets in real time. While part of the Elastic Stack (formerly ELK Stack), Kibana itself focuses on turning raw log and metric data stored in Elasticsearch into interactive charts, graphs, and dashboards.
Elastic

2) Key Features of Kibana

Kibana provides a rich set of features that make data interpretation and monitoring easier:

✔ Data Visualization & Dashboards — Create interactive line charts, bar graphs, pie charts, heatmaps, timelion graphs, and maps that update in real time.
Siberoloji
+1

✔ Discover & Search — Explore, filter, and query Elasticsearch data with powerful search features.
Elastic

✔ Advanced Dashboards — Combine multiple visualizations into customizable dashboards for system or business insights.
Siberoloji

✔ Security & Access Control — Role-based access control (RBAC) and secure spaces allow restricted access to specific dashboards and data.
DEV Community

✔ Reporting & Share — Export dashboards to PDF/CSV, exportable and shareable links.
DEV Community

✔ Canvas — A tool to build custom, pixel-perfect presentations using live Elasticsearch data.
DEV Community

✔ Plugins & Extensibility — Extend capabilities using plugins like Vega, Prometheus exporter, etc.
Elastic

3) How Kibana Fits into DevOps / DevSecOps

In DevOps:

Helps monitor application performance and infrastructure health by visualizing logs and metrics.

Supports troubleshooting and root-cause analysis through dashboards that show deployment, error, and usage data in real time.
DEV Community

In DevSecOps:

Enables teams to visualize security logs and threat data to detect anomalies and unusual patterns.

Used for incident investigation, alerting, and compliance reporting, improving threat monitoring and proactive response.
h2kinfosys.com
+1

Kibana effectively bridges operational performance and security analysis, making it a key observability component in modern DevOps/DevSecOps workflows.

4) Programming Language

Kibana is primarily developed using JavaScript and TypeScript, with front-end UI components built on React and a backend that interacts with Elasticsearch’s REST APIs.
DEV Community
+1

5) Parent Company

The tool is developed and maintained by Elastic, the company behind the Elastic Stack, which includes Elasticsearch, Logstash, Beats, and Kibana.
DEV Community
+1

6) Open Source or Paid?

Hybrid licensing model:

The core Kibana product is open-source/available under source-available licenses with community features.
Wikipedia

Commercial/paid features (advanced security, machine learning, enterprise alerting, etc.) are available via Elastic’s paid subscription tiers.
DEV Community

So you can use the basic version for free, but enterprises often choose paid subscriptions for full security and analytics capabilities.

Latest news in DBMS

Kanishka L — Tue, 07 Oct 2025 07:30:40 +0000

The global poster and printing market continues to expend with remarkable innovation and demand across costum digital and traditional formates

Latest news in DBMS in 2025

Kanishka L — Tue, 07 Oct 2025 07:26:37 +0000

The global poster and printing market continues to expand with remarkable innovation and demand across custom, digital, and traditional formats. 📈

MarketGrowth #PrintingIndustry #DigitalTransformation #PosterDesign #Innovation #VisualMarketing #BusinessTrends2025

MangoDB

Kanishka L — Tue, 07 Oct 2025 07:21:27 +0000

I decided to use MongoDB for building my blog. As I have never worked with MongoDB before, I still have to figure out how to get everything to work. So, the only thing left to do now is getting started with MongoDB. How do we set it up, add users, and create our database.

First, lets download the community server which is free and open source. I will be using the Windows version for my desktop and this article. After installing the software, I also installed mongosh since I am an avid command line user. After adding mongosh to my PATH variablesIt is halfway when trying to boot the server again, that I figured that using mongosh might not have been the brightest of ideas. MongoDB is already new to me and using beta software that does not support all commands yet is not making things any easier. So, I switched to the legacy mongo shell, since the documentation is up to date for that. I managed to boot the server again and logging into my database!Creating a Database
I got my authentication ready, the final step now is to create a database. You can easily create a new database in MongoDB with the use command. If the database doesn't exist yet, it creates it. Keep in mind though that MongoDB will save the database only when you put data in it. Until then, it is not saved and does not show up when using the show dbs command.

With MongoDB running on my desktop, I can finally start with a little proof of concept. I will use that proof of concept to figure out how to connect to MongoDB and add my first set of data using Spring Boot. That should allow me to get a better grip on the technologies to start implementing it for the actual project. You know... less hacky and a bit more clean. However, that is for another post!

Transactions, Deadlocks & Log-Based Recovery

Kanishka L — Tue, 07 Oct 2025 07:11:08 +0000

**Databases are powerful because they ensure data integrity even when multiple users access the system at the same time. This is managed through transactions, deadlock detection, and log-based recovery.

In this blog, I demonstrate these concepts using a single Accounts table in Oracle Live SQL.**

📌 Schema Setup
We first create a table to simulate account balances:
CREATE TABLE Accounts (
acc_no INT PRIMARY KEY,
name VARCHAR2(50),
balance INT
);

INSERT INTO Accounts VALUES (1, 'Alice', 1000);
INSERT INTO Accounts VALUES (2, 'Bob', 1500);
INSERT INTO Accounts VALUES (3, 'Charlie', 2000);

COMMIT;

1️⃣ Transaction – Atomicity & Rollback
Goal: Transfer ₹500 from Alice to Bob. Rollback before commit to ensure no partial update.
-- Start transaction
UPDATE Accounts
SET balance = balance - 500
WHERE name = 'Alice';

UPDATE Accounts
SET balance = balance + 500
WHERE name = 'Bob';

-- Rollback the transaction
ROLLBACK;

-- Check balances (should be unchanged)
SELECT * FROM Accounts;

✅ Balances remain:

Alice → 1000
Bob → 1500

Lesson: Atomicity ensures that either all operations in a transaction succeed, or none do.

2️⃣ Deadlock Simulation
Goal: Simulate a deadlock between two sessions.
Session 1: Lock Alice’s account and try to update Bob’s.
Session 2: Lock Bob’s account and try to update Alice’s.

🔥 Oracle detects circular wait → deadlock → one session is rolled back automatically.
Lesson: Deadlocks can occur when two transactions wait on each other’s locks. DBMS automatically resolves them.

3️⃣ Log-Based Recovery
Goal: Show that updates are tracked for recovery using logs.
-- Start transaction
UPDATE Accounts SET balance = balance + 1000 WHERE name = 'Alice';

-- Rollback
ROLLBACK;

-- Verify
SELECT * FROM Accounts;

✅ Even after rollback, balances are restored, demonstrating undo capability via internal logs.
Note: In Oracle Live SQL, redo/undo logs are internal. The rollback proves that log-based recovery works.

🎯 Summary
Through these demos, I explored:
✅ Atomicity & Rollback – all-or-nothing transactions
✅ Deadlocks – isolation and conflict resolution
✅ Log-Based Recovery – durability and undo operations

Special thanks to @santhoshnc Sir for guiding us to try these experiments hands-on in Oracle Live SQL.

Database Hashing

Kanishka L — Tue, 07 Oct 2025 07:06:37 +0000

I started my writing journey on Hashing but I've been wanting to expand my audience by widely publishing articles across the interwebs. I discovered dev.to as another great platform to share developer-related content.Dev.to has dedicated support for posting to the community from RSS. Additionally, dev.to supports canonical linking to protect SEO rankings. Luckily, Hashnode provides an RSS feed so republishing content from Hashnode onto dev.to is easy and fast.

You can find your Hashnode RSS example, my. You can also find it linked on your blog page. See the arrow in the screenshot below for the location.After creating a dev.to account, open the settings and head to the Extensions tab. Under the Extensions tab, you will find Publishing to DEV Community from RSS. Simply copy your Hashnode RSS feed into the RSS Feed URL field and hit Save Feed Settings. After a few seconds, your Hashing articles will appear as drafts in the dev.to dashboard.

Understanding ACID Properties in SQL with Examples

Kanishka L — Tue, 07 Oct 2025 06:56:20 +0000

ACID properties — Atomicity, Consistency, Isolation, Durability — ensure that database transactions are reliable, safe, and predictable. Let’s explore them with a practical Accounts table.

Create Sample Accounts Table CREATE TABLE Accounts ( acc_no INT PRIMARY KEY, name VARCHAR2(50), balance INT CHECK (balance >= 0) -- enforce positive balance );

Insert sample data
INSERT INTO Accounts VALUES (101, 'Alice', 5000);
INSERT INTO Accounts VALUES (102, 'Bob', 3000);
INSERT INTO Accounts VALUES (103, 'Charlie', 7000);

COMMIT;

Atomicity

Definition: Either all operations in a transaction succeed, or none do.

Scenario: Transfer 1000 from Alice to Bob, but simulate a failure midway.

-- Start transaction
BEGIN
-- Deduct 1000 from Alice
UPDATE Accounts
SET balance = balance - 1000
WHERE acc_no = 101;

-- Simulate error (e.g., divide by zero)
-- This will cause the transaction to fail
-- Uncomment the following line to simulate failure
-- DECLARE x NUMBER := 1/0; END;

-- Add 1000 to Bob
UPDATE Accounts
SET balance = balance + 1000
WHERE acc_no = 102;

COMMIT; -- Will not reach here if error occurs
EXCEPTION
WHEN OTHERS THEN
ROLLBACK; -- Ensures no partial update
DBMS_OUTPUT.PUT_LINE('Transaction failed, rolled back.');
END;
/
✅ After rollback, balances remain unchanged — Atomicity is maintained.

Consistency

Definition: Transactions must leave the database in a valid state.

Scenario: Try inserting a negative balance.

-- This will fail due to the CHECK constraint
INSERT INTO Accounts VALUES (104, 'David', -500);

The database rejects this, ensuring Consistency.

Isolation

Definition: Concurrent transactions should not interfere with each other.

Scenario: Two sessions:

Session 1: Update Alice’s balance

UPDATE Accounts
SET balance = balance + 2000
WHERE acc_no = 101;
-- Do not commit yet

Session 2: Read Alice’s balance

SELECT balance FROM Accounts WHERE acc_no = 101;

Session 2 will not see the uncommitted change (depending on isolation level, default is READ COMMITTED).

This prevents dirty reads — demonstrating Isolation.

Durability

Definition: Once a transaction is committed, data persists even after a crash.

-- Commit a transaction
UPDATE Accounts
SET balance = balance + 1000
WHERE acc_no = 102;

COMMIT;

Restart the database.

Run:
SELECT * FROM Accounts;

Changes persist — Durability is guaranteed.

Summary Table
ACID Property Example Action
Atomicity Transfer money → rollback on error
Consistency CHECK constraint prevents negative balance
Isolation Concurrent reads/writes don’t interfere
Durability Committed changes persist after DB restart

💡Tip: Try changing isolation levels (READ COMMITTED, SERIALIZABLE) to observe how concurrent transactions behave differently

Cursor and Trigger

Kanishka L — Tue, 07 Oct 2025 06:33:07 +0000

A cursor in a Database Management System (DBMS) is a special control structure used to traverse and manipulate the rows in a result set one at a time. While standard SQL operations are typically set-based and act on all rows simultaneously, a cursor enables row-by-row processing, making it ideal for scenarios that require sequential logic, conditional operations, or custom computations on each individual row. Cursors are especially useful in complex business workflows where fine-grained control over data handling is necessary.

Step 1: Create Employee Table
CREATE TABLE Employee ( Emp_ID NUMBER PRIMARY KEY, Emp_Name VARCHAR2(50), Salary NUMBER );

Step 2: Insert Sample Data
INSERT INTO Employee (Emp_ID, Emp_Name, Salary) VALUES (1, 'Ramesh', 60000); INSERT INTO Employee (Emp_ID, Emp_Name, Salary) VALUES (2, 'Suresh', 45000); INSERT INTO Employee (Emp_ID, Emp_Name, Salary) VALUES (3, 'Anita', 75000); INSERT INTO Employee (Emp_ID, Emp_Name, Salary) VALUES (4, 'Kavya', 50000);

Step 3: Create and Process Cursor
OPEN emp_cursor; LOOP FETCH emp_cursor INTO v_EmpName, v_Salary; EXIT WHEN emp_cursor%NOTFOUND; DBMS_OUTPUT.PUT_LINE('Employee: ' || v_EmpName || ', Salary: ₹' || v_Salary); END LOOP; CLOSE emp_cursor; END;

DBMS_OUTPUT.PUT_LINE prints each employee’s name and salary.

DEFINITION OF TRIGGER IN DBMS

A trigger in DBMS is a special stored procedure that automatically executes in response to events like INSERT, UPDATE, or DELETE on a table or view. It’s commonly used to enforce business rules, maintain data integrity, and log changes without manual intervention.

Step 1: Create Students Table
CREATE TABLE Students ( Student_ID NUMBER PRIMARY KEY, Student_Name VARCHAR2(50), Course VARCHAR2(50) );

Step 2: Create Student_Audit Table
CREATE TABLE Student_Audit ( Audit_ID NUMBER GENERATED ALWAYS AS IDENTITY PRIMARY KEY, Student_ID NUMBER, Student_Name VARCHAR2(50), Action VARCHAR2(50), Action_Time TIMESTAMP );

Step 3: Create AFTER INSERT Trigger
CREATE OR REPLACE TRIGGER trg_after_student_insert AFTER INSERT ON Students FOR EACH ROW BEGIN INSERT INTO Student_Audit (Student_ID, Student_Name, Action, Action_Time) VALUES (:NEW.Student_ID, :NEW.Student_Name, 'INSERT', SYSTIMESTAMP); END;

Step 4: Test Trigger
INSERT INTO Students (Student_ID, Student_Name, Course) VALUES (1, 'Ravi', 'Computer Science'); INSERT INTO Students (Student_ID, Student_Name, Course) VALUES (2, 'Meena', 'Electrical Engineering');

Step 5: Verify Audit Table
SELECT * FROM Student_Audit;

Database Normalization

Kanishka L — Tue, 07 Oct 2025 06:23:33 +0000

Database normalization is the process of structuring a relational database to reduce redundancy and improve data integrity.

In this blog, we'll normalize a student-course-instructor dataset from Unnormalized Form 1NF ← 2NF ←

3NF, and implement it in SQL.

Step 1: Base Table

The initial unnormalized table includes details of students, their courses, instructors, and corresponding grades.Step 2: Identifying Anomalies

Insertion anomaly: A new course cannot

be added unless it is linked to a student.

Update anomaly: Modifying a course

name requires updating it in several rows.

Deletion anomaly: Removing a student

may also remove valuable course details if that student was the only enrollee.

1 First Normal Form (1NF)

Rule: Eliminate repeating groups, ensure atomic values.

So, we split multi-valued attributes into separate rows:Step 2: Identifying Anomalies

Insertion anomaly: A new course cannot

be added unless it is linked to a student.

Update anomaly: Modifying a course

name requires updating it in several rows.

Deletion anomaly: Removing a student

may also remove valuable course details if that student was the only enrollee.1 First Normal Form (1NF)

Rule: Eliminate repeating groups, ensure atomic values.

So, we split multi-valued attributes into separate rows:SQL Table in 1 NF,

CREATE TABLE Students_1NF (

Student_ID INT,

Student_Name VARCHAR2(100),

Course_ID INT,

Course_Name VARCHAR2(100),

Instructor VARCHAR2(100),

Grade CHAR(2),

PRIMARY KEY (Student_ID, Course_ID) );2 Second Normal Form (2NF)

Rule: Remove partial dependency → non-key attributes should depend on thewhole primary key.

Here, student_id depends on student info, course_id depends on course info, and instructor depends on the course.

So, we split into three tables:

SQL Create Tables (2NF):

CREATE TABLE Students ( StudentID VARCHAR2(10) PRIMARY KEY, StudentName VARCHAR2(100) );

CREATE TABLE Courses ( CourseID VARCHAR2(10) PRIMARY KEY, CourseName VARCHAR2(100), Instructor VARCHAR2(100), InstructorPhone VARCHAR2(15) );

CREATE TABLE Enrollments ( StudentID VARCHAR2(10), CourseID VARCHAR2(10),PRIMARY KEY (StudentID, CourseID), FOREIGN KEY (StudentID) REFERENCES Student(StudentID), FOREIGN KEY (CourseID) REFERENCES Course (CourseID) );3 Third Normal Form (3NF)

Rule: Remove transitive dependenciesnon-key attributes depending on other non-key attributes).

Here, instructor_phone depends on instructor, not on course_id. So we separate Instructor data:

SQL Create Tables (3NF):

REATE TABLE Instructors ( InstructorID VARCHAR2(10) PRIMARY KEY, InstructorName VARCHAR2(100), InstructorPhone VARCHAR2(15)

);

CREATE TABLE Courses3NF ( CourseID VARCHAR2(10) PRIMARY KEY, CourseName VARCHAR2(100), InstructorID VARCHAR2(10), FOREIGN KEY (InstructorID) REFERENCES Instructor(InstructorID) );CREATE TABLE Students3NF ( StudentID VARCHAR2(10) PRIMARY KEY, StudentName VARCHAR2(100) );

CREATE TABLE Enrollments3NF ( StudentID VARCHAR2(10), CourseID VARCHAR2(10), PRIMARY KEY (StudentID, CourseID), FOREIGN KEY (StudentID) REFERENCES Student3NF(StudentID), FOREIGN KEY (CourseID) REFERENCES Course3NF(CourseID) );Step 6: Insert Sample Data

Instructors

INSERT INTO Instructor VALUES ('101', 'Dr.

Kumar', '9876543210');

INSERT INTO Instructor VALUES ('102', 'Dr.

Mehta', '9123456780');

INSERT INTO Instructor VALUES ('103', 'Dr.

Rao', '9988776655');

Courses

INSERT INTO Course3NF VALUES ('C101', 'DBMS', '101');

INSERT INTO Course3NF VALUES ('C102',

'Data Mining', '102');

INSERT INTO Course3NF VALUES ('C103', 'ΑΙ', '103');

Students

INSERT INTO Student3NF VALUES ('S01', 'Arjun');

INSERT INTO Student3NF VALUES ('S02',

'Priva'):Enrollment

INSERT INTO Enrollment3NF VALUES ('S01', 'C101');

INSERT INTO Enrollment3NF VALUES ('S01', 'C102');

INSERT INTO Enrollment3NF VALUES ('S02', 'C101');

INSERT INTO Enrollment3NF VALUES ('S03', 'C103');Step 7: Query with JOINS

SELECT s.StudentName, c.CourseName, i.InstructorName

FROM Enrollment3NF e

JOIN Student3NF s ON e. StudentID =s.StudentID

JOIN Course3NF c ON e. CourseID = c.CourselD

JOIN Instructor i ON c.InstructorID = i.InstructorID;** Wrap Up**

We started with an unnormalized table and step-by-step applied:

1NF ← Removed repeating groups

2NF ← Removed partial dependencies

3NF ← Removed transitive dependencies

Result

A clean, normalized database3NF

← Removed transitive dependencies

← Result A clean, normalized database with reduced redundancy, better integrity, and easier queries

Special thanks to @santhoshnc for mentoring me on database normalization concepts!

SQL #Oracle

DBMS

DatabaseNormalization

1NF

2NF

3NF

BCNF

4NF

5NF

DataModeling

College Student & Course Management System (Oracle LiveSQL) sql #oracle #database #tutorial

Kanishka L — Mon, 25 Aug 2025 12:21:47 +0000

Introduction

In this blog, I’ll walk you through my hands-on implementation of a College Student & Course Management System using Oracle LiveSQL.
This project helped me practice real-world SQL concepts such as table creation, data insertion, constraints, queries, and views.

What’s Covered?

✅ Table creation
✅ Data insertion
✅ Constraints & table alterations
✅ SQL queries with string functions & aggregates
✅ Joins
✅ Views
✅ Grouping with HAVING

1. Table Creation

I started by creating the core tables – Students, Faculty, and Courses.

CREATE TABLE Students (
StudentID NUMBER PRIMARY KEY,
Name VARCHAR2(50) NOT NULL,
Dept VARCHAR2(30),
DOB DATE,
Email VARCHAR2(50) UNIQUE
);

CREATE TABLE Faculty (
FacultyID NUMBER PRIMARY KEY,
FacultyName VARCHAR2(50) NOT NULL,
Dept VARCHAR2(30),
Email VARCHAR2(50) UNIQUE
);

CREATE TABLE Courses (
CourseID NUMBER PRIMARY KEY,
CourseName VARCHAR2(50) NOT NULL,
Credits NUMBER(2) CHECK (Credits BETWEEN 1 AND 5)
);

2. Data Insertion

Next, I inserted some sample data into the tables.

INSERT INTO Students VALUES (1, 'Aarav Kumar', 'Computer Science', TO_DATE('2004-05-12','YYYY-MM-DD'), 'aarav.cs@example.com');
INSERT INTO Students VALUES (2, 'Meera Reddy', 'Electrical', TO_DATE('2003-09-23','YYYY-MM-DD'), 'meera.ee@example.com');
INSERT INTO Students VALUES (3, 'Vikram Sharma', 'Mechanical', TO_DATE('2004-01-30','YYYY-MM-DD'), 'vikram.me@example.com');

3. Altering Tables

Adding a new column PhoneNo for storing 10-digit mobile numbers:

ALTER TABLE Students
ADD PhoneNo VARCHAR2(10);

4. Queries with String Functions

Example: Display student names in uppercase and the length of their email IDs.

SELECT UPPER(Name) AS StudentName_Uppercase,
LENGTH(Email) AS Email_Length
FROM Students;

5. Joins & Views

Created an Enrollments table to link students with courses and store grades.

CREATE TABLE Enrollments (
StudentID NUMBER REFERENCES Students(StudentID),
CourseID NUMBER REFERENCES Courses(CourseID),
Grade VARCHAR2(2)
);

Then created a view to see student-course-grade details:

CREATE OR REPLACE VIEW StudentCoursesView AS
SELECT s.Name AS StudentName, c.CourseName, e.Grade
FROM Students s
JOIN Enrollments e ON s.StudentID = e.StudentID
JOIN Courses c ON e.CourseID = c.CourseID;

6. Aggregates & Grouping

Example: Find the average credits of all courses and the total number of students enrolled.

SELECT AVG(Credits) AS AvgCredits,
COUNT(DISTINCT StudentID) AS TotalStudents
FROM Enrollments e
JOIN Courses c ON e.CourseID = c.CourseID;

Conclusion

This mini project gave me hands-on practice with:

SQL DDL (table creation, alteration)
SQL DML (insertion, updates)
Constraints
Queries using string & aggregate functions
Joins and Views

It’s a simple yet effective way to strengthen SQL concepts using Oracle LiveSQL 🚀.