DEV Community: Pavithra Sai

DES Encryption Explained Simply

Pavithra Sai — Tue, 06 Jan 2026 15:35:23 +0000

INTRODUCTION

Cryptography is used everywhere today — from passwords to secure messages.
One of the earliest and most popular encryption algorithms is DES
(Data Encryption Standard).

In this blog, I will explain DES in a very simple way,
using easy language, screenshots from code, and clear diagrams.
Even beginners can understand how DES works.

WHAT IS DES?

DES (Data Encryption Standard) is a symmetric key encryption algorithm.
This means the same secret key is used for both encryption and decryption.

DES was developed in the 1970s and works on fixed-size data blocks.
Even though DES is no longer considered secure today,
it is very important to understand it for learning cryptography basics.

BASIC DETAILS OF DES

• Type: Symmetric key encryption  
• Block size: 64 bits  
• Key size: 56 bits  
• Number of rounds: 16

HOW DES WORKS

DES works by repeatedly mixing the data using a secret key.
The input text is split into two halves and processed for 16 rounds.
Each round increases confusion and diffusion,
making the encrypted data difficult to understand without the key.

STEP-BY-STEP WORKING OF DES

Plain Text Input

DES takes 64 bits of plain text as input.
This text is divided into two equal halves:
Left (32 bits) and Right (32 bits).

One DES Round

Each DES round follows the same pattern:

1. The Right part is processed using a function called f().
2. The output of f() is XORed with the Left part.
3. The Left and Right parts are swapped.

Formula

New Left  = Old Right
New Right = Old Left XOR f(Old Right, Key)

Why 16 Rounds

DES repeats the same process 16 times.
Each round increases security by mixing the data further.
After 16 rounds, the final output becomes the cipher text.

ENCRYPTION PROCESS

Below is a simple demonstration of DES encryption.
The same plain text and key always produce the same cipher text.

DECRYPTION PROCESS

DES decryption uses the same algorithm in reverse order.
The same secret key is required to recover the original plain text.

ENCRYPTION vs DECRYPTION

| Feature | Encryption      | Decryption      |
|         |                 |                 |
| Input   | Plain Text      | Cipher Text     |
| Key     | Same Secret Key | Same Secret Key |
| Output  | Cipher Text     | Plain Text      |

LIMITATIONS OF DES

• Small key size (56 bits)
• Vulnerable to brute-force attacks
• No longer secure for modern applications

DES vs MODERN ALGORITHMS

Due to its weaknesses, DES has been replaced by stronger algorithms like AES.
However, DES is still widely taught for understanding
the foundations of encryption systems.

CONCLUSION

DES is a classic encryption algorithm that helps beginners
understand how block ciphers work.
While it should not be used in real-world security today,
learning DES provides a strong base for understanding modern cryptography.

Polly – Amazon Polly Convert Text into Natural Speech Using AWS

Pavithra Sai — Thu, 18 Dec 2025 16:42:29 +0000

Description:

Learn how Amazon Polly, an AWS service, converts text into lifelike speech using artificial intelligence.
tags: aws, cloud, ai, devops

Amazon Polly – Text to Speech Made Easy

In modern applications, voice-based interaction is becoming very common.

From virtual assistants to accessibility tools, speech plays a major role.

Amazon Polly is an AWS service that helps convert text into natural-sounding speech.

What is Amazon Polly?

Amazon Polly is a Text-to-Speech (TTS) service provided by Amazon Web Services (AWS).

It uses advanced machine learning and deep learning technologies to generate realistic human voices.

With Polly, developers can easily add speech capability to their applications.

Why Use Amazon Polly?

Traditional voice recording:

Time-consuming
Difficult to update
Not scalable

With Amazon Polly:

No manual voice recording
Multiple languages & voices
Scalable & fast
Pay only for what you use

How Amazon Polly Works

Input text is provided to Polly
Select language and voice
Polly converts text into speech
Output is an audio file (MP3, WAV, etc.)

Key Features of Amazon Polly

Supports 30+ languages
Multiple male & female voices
Neural Text-to-Speech (NTTS)
Real-time and batch processing
Supports SSML (Speech Synthesis Markup Language)

Real-Time Use Cases

Amazon Polly is widely used in:

Voice assistants
E-learning platforms
Accessibility applications
News readers
IVR systems

Amazon Polly in AWS Ecosystem

Amazon Polly integrates well with:

AWS Lambda
Amazon S3
Amazon Transcribe
Amazon Lex

This makes it ideal for serverless and AI-based applications.

Advantages of Amazon Polly

Improves user experience
Easy to integrate using AWS SDKs
No infrastructure management
Highly reliable and scalable

Limitations

Requires internet connectivity
Cost depends on characters processed
Advanced voices cost slightly more

Conclusion

Amazon Polly is a powerful AWS service that brings voice to applications.

It helps developers build interactive, accessible, and intelligent systems with minimal effort.

For anyone exploring AWS, Cloud, or AI services, Amazon Polly is worth learning.

My sincere thanks to @santhoshnc for giving this assignment, which helped me learn about Amazon Polly and AWS services.

🔗 References

Amazon Polly – Official AWS Documentation

Packer in DevOps – Build Once, Deploy Anywhere

Pavithra Sai — Thu, 18 Dec 2025 16:12:50 +0000

Description:

Learn how HashiCorp Packer helps DevOps engineers automate machine image creation for cloud and CI/CD pipelines.
In DevOps, consistency and automation are very important.

Manual server setup often leads to errors and time waste.

This is where Packer helps us.
Tags: devops, packer, cloud, automation

Console Link: Official Packer Documentation

What is Packer?

Packer is an open-source tool developed by HashiCorp.

It is used to create machine images automatically.

Using Packer, we can build:

AWS AMIs
Azure VM Images
Google Cloud Images
Docker Images

Once an image is built, it can be reused anywhere.

Why Do We Need Packer?

Traditional approach:

Manual server configuration
Configuration mismatch
Slow deployments

With Packer:

Consistent images
Faster provisioning
Automation friendly
Works well with CI/CD

How Packer Works

Write a Packer configuration file (.pkr.hcl)
Choose a base OS image
Use provisioners (Shell, Ansible, etc.)
Run packer build
Get a ready-to-use image

Real-Time Example

Imagine launching multiple EC2 instances with the same software.

Without Packer:

Manual setup for every server

With Packer:

Build AMI once
Launch multiple EC2 instances instantly

🙏 Acknowledgement

I would like to sincerely thank @santhoshnc for giving this assignment.

This task helped me explore Packer as a DevOps tool and understand how image automation plays a crucial role in real-world DevOps workflows.

The assignment motivated me to learn beyond theory and apply concepts practically.

Thank you, sir, for the guidance and encouragement.

Sample Packer Configuration


hcl
source "amazon-ebs" "example" {
  region        = "ap-south-1"
  instance_type = "t2.micro"
  ami_name      = "packer-demo-ami"
  source_ami    = "ami-xxxxxxxx"
  ssh_username  = "ubuntu"
}

build {
  sources = ["source.amazon-ebs.example"]

  provisioner "shell" {
    inline = [
      "sudo apt update",
      "sudo apt install nginx -y"
    ]
  }
}

MongoDB - Blog

Pavithra Sai — Fri, 03 Oct 2025 10:35:09 +0000

Hands-On CRUD Operations in MongoDB Using a Student Schema

MongoDB is a popular NoSQL database that stores data in flexible, JSON-like documents rather than traditional tables. In this tutorial, we’ll explore CRUD operations (Create, Read, Update, Delete) using a simple college student schema. By the end, you’ll be comfortable performing these operations in MongoDB Atlas.

Student Schema

Each student document follows this structure:

{
  "student_id": "S001",
  "name": "Santhosh",
  "age": 20,
  "department": "CSBS",
  "year": 2,
  "cgpa": 9
}

We will use a collection called students to store these documents.

1️⃣ Create (Insert) Students

We’ll insert 5 student records into the students collection.

  { "student_id": "S001", "name": "Santhosh", "age": 20, "department": "CSBS", "year": 2, "cgpa": 9 },
  { "student_id": "S002", "name": "Kiran", "age": 21, "department": "CSE", "year": 3, "cgpa": 8.5 },
  { "student_id": "S003", "name": "Anita", "age": 19, "department": "ECE", "year": 2, "cgpa": 7.8 },
  { "student_id": "S004", "name": "Ramesh", "age": 22, "department": "CSE", "year": 3, "cgpa": 8.2 },
  { "student_id": "S005", "name": "Priya", "age": 20, "department": "CSBS", "year": 1, "cgpa": 9.1 }
]);

💡 Tip: insertMany() allows inserting multiple documents in one
command.

2️⃣ Read (Query) Students

Display all students:

db.students.find().pretty();

Find students with CGPA > 8:

db.students.find({ "cgpa": { $gt: 8 } });

Find students in the Computer Science department (CSE):db.students.find({ "department": "CSE" });`

3️⃣ Update Students

Update CGPA of a specific student (S002):

db.students.updateOne( { "student_id": "S002" }, { $set: { "cgpa": 9 } } );
Increase year of all 3rd-year students by 1:

`
db.students.updateMany(
{ "year": 3 },
{ $inc: { "year": 1 } }
);

💡 Tip: $set updates a field, while $inc increments numerical values.

4️⃣ Delete Students

Delete a student by student_id (S003):

db.students.deleteOne({ "student_id": "S003" });

Delete all students with CGPA < 7.5:

db.students.deleteMany({ "cgpa": { $lt: 7.5 } });

Conclusion

In this tutorial, we explored how to create, read, update, and delete student records in MongoDB using a simple schema. MongoDB Atlas makes database management interactive and easy, giving us hands-on experience with real-world operations.

Final Collection Sample

[{ "student_id": "S002", "name": "Kiran", "age": 21, "department": "CSE", "year": 3, "cgpa": 8.5 }, { "student_id": "S003", "name": "Anita", "age": 19, "department": "ECE", "year": 2, "cgpa": 7.8 }, { "student_id": "S004", "name": "Ramesh", "age": 22, "department": "CSE", "year": 3, "cgpa": 8.2 }]

📌 Deliverables for this assignment:

MongoDB queries (insert, find, update, delete)
Screenshots of query execution in MongoDB Atlas
Export of the final students collection as JSON/CSV

Special thanks to @santhoshnc Sir for guiding and encouraging me throughout this assignment. Your mentorship made learning MongoDB hands-on and enjoyable! 🙏

Indexing, Hashing & Query Optimization

Pavithra Sai — Fri, 03 Oct 2025 07:44:14 +0000

Introduction

Efficient data retrieval is critical in database management. Indexing and query optimization help reduce query execution time, especially for large datasets. In this blog, I demonstrate the use of B-Tree, B+ Tree, and Hash-based indexing in Oracle SQL through a simple Students table.
I also showcase queries that benefit from these indexes. This is part of my database assignments, and I want to acknowledge my mentor Santhosh Sir for guidance and encouragement.

Step 1: Creating the Students Table

We start by creating a Students table with the following fields:

roll_no (Primary Key)
name (Student name)
dept (Department)
cgpa (Cumulative GPA)

CREATE TABLE Students (
roll_no NUMBER PRIMARY KEY,
name VARCHAR2(50),
dept VARCHAR2(20),
cgpa NUMBER(3,2)
);

Step 2: Inserting Sample Data

We insert 20 student records into the table:

INSERT INTO Students VALUES (101, 'Alice', 'CSBS', 9.1);
INSERT INTO Students VALUES (102, 'Bob', 'ECE', 7.8);
INSERT INTO Students VALUES (103, 'Charlie', 'MECH', 8.5);
INSERT INTO Students VALUES (104, 'David', 'CSBS', 6.9);
INSERT INTO Students VALUES (105, 'Eva', 'CIVIL', 8.2);
INSERT INTO Students VALUES (106, 'Frank', 'ECE', 7.5);
INSERT INTO Students VALUES (107, 'Grace', 'CSBS', 9.0);
INSERT INTO Students VALUES (108, 'Hannah', 'MECH', 8.1);
INSERT INTO Students VALUES (109, 'Ian', 'CIVIL', 7.6);
INSERT INTO Students VALUES (110, 'Jack', 'CSBS', 8.8);
INSERT INTO Students VALUES (111, 'Kiran', 'ECE', 7.9);
INSERT INTO Students VALUES (112, 'Lina', 'MECH', 8.4);
INSERT INTO Students VALUES (113, 'Mona', 'CSBS', 9.2);
INSERT INTO Students VALUES (114, 'Nina', 'CIVIL', 8.0);
INSERT INTO Students VALUES (115, 'Oscar', 'ECE', 6.8);
INSERT INTO Students VALUES (116, 'Paul', 'MECH', 7.7);
INSERT INTO Students VALUES (117, 'Quinn', 'CSBS', 8.9);
INSERT INTO Students VALUES (118, 'Rita', 'CIVIL', 7.5);
INSERT INTO Students VALUES (119, 'Steve', 'ECE', 8.3);
INSERT INTO Students VALUES (120, 'Tina', 'MECH', 8.6);

Step 3: B-Tree Index on roll_no

Since roll_no is the primary key, Oracle automatically creates a B-Tree index on this column. This ensures efficient retrieval for queries like:

SELECT * FROM Students
WHERE roll_no = 110;

Step 4: B+ Tree Index on cgpa

For range queries like cgpa > 8.0, a B+ Tree index is ideal. Oracle automatically uses B+ Tree indexing for normal indexes, so we create:

CREATE INDEX idx_cgpa ON Students(cgpa);

SELECT * FROM Students
WHERE cgpa > 8.0
ORDER BY cgpa DESC;

Step 5: Hash Index on dept (Simulated)

Oracle does not support direct hash indexes like some other databases, but we can simulate it using a normal index:

CREATE INDEX idx_dept ON Students(dept);

SELECT * FROM Students
WHERE dept = 'CSBS';

Conclusion

Through this assignment, I observed:
Primary Key automatically creates a B-Tree index → no need to manually create.

B+ Tree index is perfect for range queries (e.g., cgpa > 8.0).
Hash indexes (or equality-based indexes) optimize retrieval for categorical fields like dept.
Indexing and query optimization are crucial for efficient data retrieval, especially in large databases.

I sincerely thank @santhoshnc Sir for his guidance, assignments, and encouragement, which helped me understand indexing and query optimization in Oracle SQL.

Transactions, Deadlocks & Log Based Recovery

Pavithra Sai — Fri, 03 Oct 2025 07:15:23 +0000

Transactions, Deadlocks & Log-Based Recovery – Hands-on SQL Demo

**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.

ACID Properties & SQL Transactions

Pavithra Sai — Thu, 02 Oct 2025 19:21:38 +0000

Summary

This post walks through creating an Accounts table, inserting seed data, updating balances with transactions, and demonstrating a CHECK constraint violation. It also ties each step to ACID properties with clear visuals.

What you’ll learn

Create/insert into an Accounts table and verify results with SELECT
Run UPDATE + COMMIT cycles and validate row changes
Trigger and understand a CHECK constraint error for data integrity
Map each step to ACID: Atomicity, Consistency, Isolation, Durability

1) Setup: create and insert

CREATE TABLE Accounts (
acc_no NUMBER PRIMARY KEY,
name VARCHAR2(50) NOT NULL,
balance NUMBER(12,2) CONSTRAINT chk_balance CHECK (balance >= 0)
);

INSERT INTO Accounts (acc_no, name, balance) VALUES (101, 'Alice', 4000);
INSERT INTO Accounts (acc_no, name, balance) VALUES (102, 'Bob', 4000);
INSERT INTO Accounts (acc_no, name, balance) VALUES (103, 'Charlie', 2000);
COMMIT;

SELECT * FROM Accounts;

2) Transactions: update and commit

-- Apply bonus to 101 and 102
UPDATE Accounts SET balance = balance + 1000 WHERE acc_no = 101;
UPDATE Accounts SET balance = balance + 1000 WHERE acc_no = 102;
COMMIT;

SELECT * FROM Accounts;

3) Quick verification: single account

SELECT balance FROM Accounts WHERE acc_no = 101;

4) Constraint demo: negative balance (expected error)

-- Integrity check: should fail
INSERT INTO Accounts (acc_no, name, balance) VALUES (104, 'David', -500);

ACID refresher with visuals

Atomicity: A transaction is all‑or‑nothing—either the whole unit commits or none persists.

Consistency: Only valid states reach the database; constraints enforce rules at the boundary.

Isolation: Concurrent work shouldn’t interfere; each transaction sees a consistent snapshot.

Durability: After COMMIT, data survives failures and session ends.

-- Create + seed
CREATE TABLE Accounts (
acc_no NUMBER PRIMARY KEY,
name VARCHAR2(50) NOT NULL,
balance NUMBER(12,2) CONSTRAINT chk_balance CHECK (balance >= 0)
);

SELECT * FROM Accounts;

-- Updates
UPDATE Accounts SET balance = balance + 1000 WHERE acc_no = 101;
UPDATE Accounts SET balance = balance + 1000 WHERE acc_no = 102;
COMMIT;

-- Verifications
SELECT balance FROM Accounts WHERE acc_no = 101;
SELECT * FROM Accounts;

-- Constraint violation demo (will error)
INSERT INTO Accounts (acc_no, name, balance) VALUES (104, 'David', -500);

Credits

Thank you, @santhoshnc Sir, for the assignment and guidance—this write‑up is the direct result of that mentorship.

Cursor & Trigger

Pavithra Sai — Thu, 02 Oct 2025 18:29:31 +0000

Summary

A quick walkthrough of Oracle Live SQL practice: creating a table, printing output with SERVEROUTPUT, iterating a cursor, and building an AFTER INSERT trigger to log into an audit table, with screenshots and runnable snippets.

What this post covers

Create and seed an Employee table
Use SET SERVEROUTPUT ON for DBMS_OUTPUT in Live SQL
Loop over rows using a cursor and print names to the script output pane
Write a simple auditing trigger for student inserts and verify audit rows ## 1) Create table + sample data

CREATE TABLE Employee (
EmployeeID INT PRIMARY KEY,
Name VARCHAR2(50),
Salary NUMBER(10,2)
);

INSERT INTO Employee VALUES (1, 'Alice', 60000);
INSERT INTO Employee VALUES (2, 'Bob', 45000);
INSERT INTO Employee VALUES (3, 'Charlie', 75000);
INSERT INTO Employee VALUES (4, 'David', 50000);

2) Print output with DBMS_OUTPUT

SET SERVEROUTPUT ON;

DECLARE
v_count NUMBER;
BEGIN
SELECT COUNT(*) INTO v_count FROM Employee;
DBMS_OUTPUT.PUT_LINE('Rows in Employee: ' || v_count);
END;
/

3) Cursor demo: list high earners

SET SERVEROUTPUT ON;

DECLARE
CURSOR c_emp IS
SELECT Name FROM Employee WHERE Salary > 50000 ORDER BY Salary DESC;

v_name Employee.Name%TYPE;
BEGIN
OPEN c_emp;
LOOP
FETCH c_emp INTO v_name;
EXIT WHEN c_emp%NOTFOUND;
DBMS_OUTPUT.PUT_LINE(v_name);
END LOOP;
CLOSE c_emp;
END;
/

4) Build a simple audit trigger

-- Base tables
CREATE TABLE Students (
StudentID NUMBER PRIMARY KEY,
Name VARCHAR2(50)
);

CREATE TABLE Student_Audit (
AuditID NUMBER GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
StudentID NUMBER,
StudentName VARCHAR2(50),
Action VARCHAR2(20),
ActionDate DATE
);

-- AFTER INSERT row-level trigger to capture inserts
CREATE OR REPLACE TRIGGER trg_students_ins_audit
AFTER INSERT ON Students
FOR EACH ROW
BEGIN
INSERT INTO Student_Audit (StudentID, StudentName, Action, ActionDate)
VALUES (:NEW.StudentID, :NEW.Name, 'Inserted', SYSDATE);
END;
/

Dev.to formatting tips

Use fenced code blocks with language hints like ```

Keep one blank line before and after code blocks for clean rendering in Markdown-based editors like Dev.to.
If showing code that itself contains backticks, use a longer fence (four or more backticks) to avoid premature closing in Markdown processors.

This post is dedicated to @santhoshnc Sir thank you for the assignment and continuous support.

Database Normalization

Pavithra Sai — Thu, 02 Oct 2025 17:33:23 +0000

Normalizing a Student-Course schema step-by-step and validating with JOIN outputs

Introduction

This post shows how a simple Student–Course dataset was modeled in Oracle Live SQL and normalized from 1NF → 2NF → 3NF, ending with a clean junction table and a working JOIN query result. The screenshots are added to illustrate each milestone and the final output table. Special thanks to Santhosh sir for assigning and guiding this exercise.

What problem I solved

Started with a single wide table mixing student, course, and instructor details, which risks redundancy and update anomalies.

Applied normalization to split data into well-structured tables and enforce referential integrity.

Verified with INSERT and SELECT … JOIN to ensure the design works end-to-end.

1NF: Single wide table

Created an initial table StudentCourse1NF with columns: StudentID, StudentName, CourseID, CourseName, Instructor, InstructorPhone.
Goal at this stage: ensure atomic values in each cell and a primary identifier present.

2NF: Remove partial dependencies

Identified that non-key attributes like StudentName depend on StudentID, while CourseName/Instructor details depend on CourseID, causing partial dependency on a composite key.

Split into base entity tables: Students(StudentID, StudentName) and Courses(CourseID, CourseName, Instructor, InstructorPhone).
Created a pure relationship table StudentCourse1NF_New or StudentCourses with keys only (StudentID, CourseID).

3NF: Remove transitive dependencies

Ensured instructor details belong with Courses, not with Students–Courses mapping, avoiding transitive dependencies via CourseID.
Declared composite primary key on StudentCourses(StudentID, CourseID) and foreign keys referencing Students and Courses.
This guarantees each fact lives in exactly one place, preventing update anomalies.

DDL snippets used

Students

CREATE TABLE Students (

StudentID VARCHAR2(10) PRIMARY KEY,

StudentName VARCHAR2(50)

);

Courses

CREATE TABLE Courses (

CourseID VARCHAR2(10) PRIMARY KEY,

CourseName VARCHAR2(50),

Instructor VARCHAR2(50),

InstructorPhone VARCHAR2(15)

);

StudentCourses (junction)

CREATE TABLE StudentCourses (

StudentID VARCHAR2(10),

CourseID VARCHAR2(10),

PRIMARY KEY (StudentID, CourseID),

FOREIGN KEY (StudentID) REFERENCES Students(StudentID),

FOREIGN KEY (CourseID) REFERENCES Courses(CourseID)

);

Sample data

INSERT INTO Students VALUES ('S01','Kiran');

INSERT INTO Students VALUES ('S02','Arjun');

INSERT INTO Students VALUES ('S03','Priya');

INSERT INTO Courses VALUES ('C101','DBMS',1); // or include instructor fields per your design

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

Continue adding rows to cover multiple students and courses.

*Validation query
*
SELECT s.StudentName, c.CourseName, i.InstructorName

FROM StudentCourses sc

JOIN Students s ON sc.StudentID = s.StudentID

JOIN Courses c ON sc.CourseID = c.CourseID

JOIN Instructors i ON c.InstructorID = i.InstructorID; // if you separated Instructors

What the screenshots show

1NF image: The initial table creation for denormalized structure.

2NF image: Refactoring tables and creating entity tables.

3NF image: Final DDL with keys and foreign keys in Oracle Live SQL.

Final output image: Query result proving the relationships and data integrity.

Key takeaways

Use a junction table for many-to-many Student–Course relationships.

Keep attributes with the entity they truly describe to avoid redundancy.

Composite PK on (StudentID, CourseID) plus FKs gives strong integrity.

Always validate by inserting data and running JOINs to see real results.

A sincere thanks to @santhoshnc sir for giving this assignment and motivating the step-by-step approach. Your guidance made normalization concepts much clearer in practice.