DEV Community: Hareesh

“AZ-305 Explained: Designing Microsoft Azure Infrastructure Solutions”

Hareesh — Mon, 22 Dec 2025 03:30:09 +0000

📌 Overview of the Tool / Exam

Designing Microsoft Azure Infrastructure Solutions (AZ-305) is a Microsoft certification exam for cloud and infrastructure architects. It measures your ability to design Azure solutions that address identity, governance, monitoring, storage, networking, business continuity, and infrastructure as a whole. Passing this exam contributes to the Microsoft Certified: Azure Solutions Architect Expert certification.

Unlike traditional software tools, AZ-305 is an exam that validates skills in designing and planning Azure infrastructure solutions rather than a specific piece of software.

⭐ Key Features / Skills Covered

The AZ-305 exam tests competencies across multiple architectural design areas:

🧠 Core Skill Domains

Design identity, governance, and monitoring solutions – secure access, policies, logs, metrics.
Design data storage solutions – relational & non-relational storage strategies.
Design business continuity and disaster recovery solutions – high availability, backups.
Design infrastructure solutions – compute, network connectivity, application architectures, migrations.

These areas ensure you can architect complete Azure solutions that are secure, resilient, performant, and aligned with business needs.

🔁 How It Fits into DevOps / DevSecOps

Although AZ-305 is not a DevOps tool, it strongly connects to DevOps and DevSecOps practices:

🛠️ DevOps Alignment

Focus on Infrastructure as Code (IaC) — designing infrastructure that can be automated and deployed consistently. ([examcollection.com][3])
Supports architects working with CI/CD pipelines and DevOps teams to deliver solutions that integrate with Azure DevOps or GitHub Actions for automated rollouts.

🔐 DevSecOps Alignment

Security and governance are explicitly tested (identity, access, policy). ([Microsoft Learn][1])
Ensures designs embed security best practices, continuous compliance with policies, and resilience against threats. ([examcollection.com][3])

So AZ-305 complements DevOps/DevSecOps processes by validating the architectural skills needed to design secure, reliable, and automated cloud infrastructure.

💻 Programming Language

AZ-305 does not mandate a specific programming language because it’s an architectural design exam rather than a coding certification. However, you’ll often work with languages and tools in practice such as:

CLI and scripting: PowerShell, Azure CLI
IaC tools’ languages: Bicep, ARM templates, Terraform (HCL)
General clouds and application languages like C#, Python, JavaScript may be used in solutions you design

These languages are used to implement and automate the infrastructure, but not specifically tested as “coding” questions in the exam.

🏢 Parent Organization

Owner & Sponsor: Microsoft Corporation
Certification Path: Part of Microsoft Certified: Azure Solutions Architect Expert — this credential reflects advanced expertise in Azure design and architecture.

There’s no single company behind “AZ-305” other than Microsoft itself, since it’s a proprietary exam within the Microsoft certification ecosystem.

💰 Open Source or Paid?

AZ-305 Exam 🔒 Paid – You must pay an exam fee (e.g., ~$165 USD; varies by region).
Microsoft Learn study resources 🆓 Free – Official documentation and learning paths are free.
Third-party training courses 💸 Often Paid – Courses and practice exams from other providers may cost money

AZ-305 itself is a paid, proprietary Microsoft exam, not an open-source tool or free certification.

HashiCorp Packer: Automating Machine Images for DevOps and DevSecOps

Hareesh — Mon, 22 Dec 2025 03:21:17 +0000

📌 Overview of the Tool

HashiCorp Packer is a tool for automating the creation of machine images for various platforms (cloud, virtual machines, containers) using a single source configuration. It lets you define how to build images once and produce identical artifacts for AWS, Azure, GCP, Docker, VMware, and other environments.

Packer focuses on immutable infrastructure by generating pre‑configured, deployable images (e.g., AMIs, container images) that can be reused across environments.

⭐ Key Features

1. Multi‑Platform Image Builds
Create consistent images for multiple platforms (cloud providers and virtualization systems) from a single template.

2. Templates Using HCL/JSON
Packer uses HashiCorp Configuration Language (HCL) or JSON to define how images are built — including builders, provisioners, and post‑processors.

3. Parallel Build Support
Build images for many targets simultaneously to speed up image creation.

4. Provisioners and Plugins
Integrate provisioners like shell scripts, Ansible, Chef, etc., to configure images during build time. Support for plugins/extensions enables extending functionality.

5. Integration With CI/CD
Automate image creation as part of build pipelines for more consistent deployments.

6. Golden Image Management
Standardize golden images across teams and environments, helping maintain policy, compliance, and consistency.
🔁 How It Fits into DevOps / DevSecOps

🧠 DevOps Alignment

Infrastructure as Code (IaC): Packer codifies image builds in configuration files, aligning with IaC principles.
CI/CD Integration: Works well in automated build pipelines (GitHub Actions, Azure DevOps, Jenkins), producing images as a pipeline artifact.
Immutable Artifacts: With Packer, teams can bake software and dependencies into images, reducing configuration drift during deployments.

🔐 DevSecOps Alignment

Security Standards Built In: By automating image builds with security configurations and compliance checks, Packer helps enforce secure baselines early in the lifecycle.
Repeatable Secure Builds: Ensures the same hardened image is used across environments instead of manual image setup.

So Packer supports both DevOps automation and DevSecOps secure infrastructure practices.

💻 Programming Language

Written in: Go (Golang) — a performant language that produces standalone binaries across platforms.
Configuration: Packer templates use HCL (HashiCorp Configuration Language) (preferred) or JSON.
Plugin integrations and ecosystem extensions are also designed around Go.

🏢 Parent Company

Parent / Developer: HashiCorp, Inc. — a company specializing in infrastructure automation tools
HashiCorp’s toolset includes Terraform, Vault, Consul, Nomad, and others, and many of these tools are widely used in cloud and DevOps workflows. (HashiCorp was acquired by IBM in 2025, with the acquisition closing in February 2025, so it now operates as part of IBM.)

🆓 Open Source or Paid?
Packer core tool Open‑source / free to use — source code available on GitHub under HashiCorp’s source‑available license.
Managed Service (HCP Packer) Paid / subscription tiers — advanced image management, artifact registry, and enterprise features via HashiCorp Cloud Platform (HCP).
Enterprise Support Paid support available via enterprise HashiCorp offerings or partner services.

So the core Packer tool is free and open source, but enterprise or cloud‑hosted capabilities may involve cost.

ACID Properties

Hareesh — Wed, 08 Oct 2025 12:12:05 +0000

Databases are the backbone of nearly every modern application from banking systems to e-commerce platforms. To maintain reliability and accuracy, databases follow a crucial set of principles known as ACID:
Atomicity, Consistency, Isolation, and Durability.

In this blog, let’s explore these properties through a simple Loan Management System using SQL transactions.
Creating the Schema 🧱

We’ll begin by setting up a table to store customer loan details.

Now, let’s insert some sample records:

Check the inserted data:

Atomicity — “All or Nothing”

Atomicity ensures that all operations within a transaction are completed successfully, or none at all.

Example:
Suppose we want to deduct an EMI payment of ₹5,000 from Bob’s loan account.

After rolling back, no change is reflected — demonstrating that partial updates don’t occur.

Atomicity ensures that incomplete transactions never alter the database.

Consistency — “Data Must Stay Valid”

Consistency means that a transaction should always move the database from one valid state to another, maintaining all integrity rules.

Example:
Suppose we try to insert invalid data (negative loan amount).

This will fail due to the constraint.

Consistency ensures only valid, rule-abiding data enters the system.

Isolation — “Transactions Don’t Interfere”

Isolation guarantees that concurrent transactions don’t affect each other’s intermediate states.

Example:
When two users update the same record simultaneously, one transaction waits until the other completes — preventing dirty reads or inconsistent results.

Isolation ensures safe, concurrent access to shared data.
Durability — “Committed Data Never Vanishes”

Durability ensures that once a transaction is committed, its changes persist permanently, even after system failures or restarts.

Example:
After committing a transaction:

Conclusion

By following ACID principles, databases maintain reliability, fault-tolerance, and data integrity — even under high concurrency conditions like banking, finance, or e-commerce systems.

CRUD in MongoDB

Hareesh — Wed, 08 Oct 2025 12:04:13 +0000

Creating a Student Database on MongoDB Atlas
Step 1: Setting Up MongoDB Atlas

Go to MongoDB Atlas
Create a Free Cluster (it’s totally free).
Add a Database User with a username and password.
Under “Network Access”, whitelist your IP address → 0.0.0.0/0 (allows all IPs for testing).
Click Connect → Connect with Mongo Shell, and copy your connection string.

Create (Insert):-

Insert at least 5 student records into the students collection.

We cannot start by inserting 5 student records into our students collection together. We can create each student as separate document.

Code:-
{
"student_id": "S001",
"name": "Santhosh",
"age": 20,
"department": "CSBS",
"year": 2,
"cgpa": 9
},
{
"student_id": "S002",
"name": "Baviya",
"age": 19,
"department": "CSE",
"year": 1,
"cgpa": 8.7
},
{
"student_id": "S003",
"name": "Karthik",
"age": 21,
"department": "ECE",
"year": 3,
"cgpa": 7.2
},
{
"student_id": "S004",
"name": "Anu",
"age": 20,
"department": "CSE",
"year": 2,
"cgpa": 9.3
},
{
"student_id": "S005",
"name": "Ravi",
"age": 22,
"department": "MECH",
"year": 3,
"cgpa": 6.8
}
])

READ (QUERY)

Find all students with CGPA > 8:

3️⃣ UPDATE
(a) Update the CGPA of a specific student

db.students.updateOne(
{ student_id: "S002" },
{ $set: { cgpa: 9.1 } }
)

(b) Increase the year of study for all 3rd-year students by 1

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

DELETE
(a) Delete one student record by student_id:

db.students.deleteOne({ student_id: "S005" })

(b) Delete all students having CGPA < 7.5

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

Mastering B-Tree, B+Tree, and Hash Indexes

Hareesh — Wed, 08 Oct 2025 11:47:52 +0000

Ever wondered why some SQL queries take milliseconds, while others take minutes?
The secret lies in a powerful data structure Indexes!

In this tutorial, we’ll explore how to create and use B-Tree, B+Tree, and Hash indexes using a simple Students table example.
Let’s dive right in!

🎯 What Are Indexes in Databases?

Think of an index as a shortcut just like the index in a book.
Instead of flipping through every page, the database can jump directly to the data you want.

Step 1: Create the Students Table

Step 2: Insert 20 Sample Records

Let’s fill our table with student data.

Step 3: Create a B-Tree Index on roll_no
CREATE INDEX idx_rollno ON Students(roll_no);

Step 4: Query Using B-Tree Index

SELECT * FROM Students WHERE roll_no = 110;

Step 5: Create a B+ Tree Index on cgpa

SELECT * FROM Students WHERE cgpa > 8.0;

Step 6: Query Using Hash Index

SELECT * FROM Students WHERE dept = 'CSBS';

Conclusion

We just built a mini high-performance database system from scratch!
Using B-Tree, B+Tree, and Hash indexes, you’ve learned how databases actually speed up query execution behind the scenes.

Transactions, Deadlocks & Log Based Recovery

Hareesh — Sun, 05 Oct 2025 17:26:05 +0000

Managing database transactions safely is crucial to ensure data integrity and prevent issues like partial updates or deadlocks. In this tutorial, we’ll explore transactions, deadlocks, and log-based recovery using a simple Accounts table.

First, let’s create a sample table
CREATE TABLE Accounts (
acc_no INT PRIMARY KEY,
name VARCHAR(50),
balance INT
);

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

*Transaction – Atomicity & Rollback
*
Suppose we want to transfer 500 from Alice to Bob. Using a transaction ensures that either both operations succeed or none.

START TRANSACTION;

UPDATE Accounts
SET balance = balance - 500
WHERE name = 'Alice';

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

Deadlock Simulation

Deadlocks occur when two transactions block each other waiting for resources.

START TRANSACTION;
SELECT * FROM Accounts WHERE name='Alice' FOR UPDATE;
UPDATE Accounts SET balance = balance + 100 WHERE name='Bob';

START TRANSACTION;
SELECT * FROM Accounts WHERE name='Bob' FOR UPDATE;
UPDATE Accounts SET balance = balance - 100 WHERE name='Alice';RESULT
ERROR 1213 (40001): Deadlock found when trying to get lock; try restarting transaction

Log-Based Recovery

Modern DBMS (MySQL/PostgreSQL) automatically maintain transaction logs. These logs help undo changes if a transaction fails.

UPDATE Accounts SET balance = balance - 300 WHERE name='Alice';Log-based recovery ensures that undo operations are possible. Even if the database crashes, the system can restore a consistent state.

Summary

Transactions guarantee atomicity; either all operations succeed or none.

Deadlocks occur when transactions block each other; they must be handled with care.

Log-based recovery ensures durability and recoverability

normalization

Hareesh — Sun, 05 Oct 2025 16:48:39 +0000

Database normalization is the process of organizing data to reduce redundancy and improve data integrity. In this tutorial, we’ll go step-by-step from Unnormalized Table → 1NF → 2NF → 3NF, and implement it using **MySQL.

We’ll also write a JOIN query to display students along with their courses and instructors.

Insertion Anomaly: Cannot add a new course without assigning it to a student.

Update Anomaly: If an instructor’s phone number changes, multiple rows must be updated.
Deletion Anomaly: Removing a student could delete information about the course and instructor. 1.First Normal Form (1NF)

Rule: Each column should have atomic values.

Our table already satisfies 1NF.


sql
CREATE TABLE StudentCourses_1NF (
    StudentName VARCHAR(50),
    CourseID VARCHAR(10),
    CourseName VARCHAR(50),
    Instructor VARCHAR(50),
    InstructorPhone VARCHAR(15)
);
2. Second Normal Form (2NF)

Rule: Must be in 1NF, and remove partial dependencies.

CourseName, Instructor, InstructorPhone depend only on CourseID.

StudentName depends only on the student.
-- Students Table
CREATE TABLE Students (
    StudentID INT PRIMARY KEY AUTO_INCREMENT,
    StudentName VARCHAR(50)
);

-- Courses Table
CREATE TABLE Courses (
    CourseID VARCHAR(10) PRIMARY KEY,
    CourseName VARCHAR(50),
    Instructor VARCHAR(50),
    InstructorPhone VARCHAR(15)
);

-- Enrollments Table (linking students to courses)
CREATE TABLE Enrollments (
    StudentID INT,
    CourseID VARCHAR(10),
    PRIMARY KEY (StudentID, CourseID),
    FOREIGN KEY (CourseID) REFERENCES Courses(CourseID)
);
3. Third Normal Form (3NF)

Rule: Must be in 2NF, and remove transitive dependencies.

InstructorPhone depends on Instructor.

Move instructors to a separate table.
-- Students Table
CREATE TABLE Students (
    StudentID INT PRIMARY KEY AUTO_INCREMENT,
    StudentName VARCHAR(50)
);

-- Instructors Table
CREATE TABLE Instructors (
    InstructorID INT PRIMARY KEY AUTO_INCREMENT,
    InstructorName VARCHAR(50),
    InstructorPhone VARCHAR(15)
);

-- Courses Table
CREATE TABLE Courses (
    CourseID VARCHAR(10) PRIMARY KEY,
    CourseName VARCHAR(50),
    InstructorID INT,
    FOREIGN KEY (InstructorID) REFERENCES Instructors(InstructorID)
);

-- Enrollments Table
CREATE TABLE Enrollments (
    StudentID INT,
    CourseID VARCHAR(10),
    PRIMARY KEY (StudentID, CourseID),
    FOREIGN KEY (StudentID) REFERENCES Students(StudentID),
    FOREIGN KEY (CourseID) REFERENCES Courses(CourseID)
);
4. Insert Sample Data
-- Insert Students
INSERT INTO Students (StudentName) VALUES
('Arjun'),
('Priya'),
('Kiran');

-- Insert Instructors
INSERT INTO Instructors (InstructorName, InstructorPhone) VALUES
('Dr. Kumar', '9876543210'),
('Dr. Mehta', '9123456780'),
('Dr. Rao', '9988776655');

-- Insert Courses
INSERT INTO Courses (CourseID, CourseName, InstructorID) VALUES
('C101', 'DBMS', 1),
('C102', 'Data Mining', 2),
('C103', 'AI', 3);

-- Insert Enrollments
INSERT INTO Enrollments (StudentID, CourseID) VALUES
(1, 'C101'),
(1, 'C102'),
(2, 'C101'),
(3, 'C103');

5. JOIN Query to List Students, Courses & Instructors
SELECT 
    s.StudentName,
    c.CourseName,
    i.InstructorName,
    i.InstructorPhone
FROM Enrollments e
JOIN Students s ON e.StudentID = s.StudentID
JOIN Courses c ON e.CourseID = c.CourseID
JOIN Instructors i ON c.InstructorID = i.InstructorID;
![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/d51ftxxw4jbb4c2th8iw.jpg)
![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5q8mfq8h6todc55ewhl1.jpg)
![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cujll7jvo4t0wgnlrs2m.jpg)
![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/186xyijdhqyfsvc1ucyh.jpg)
![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/f2flpv0regoryzr6lqmi.jpg)
![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8m5sb36r2ce9b4ojmgv6.jpg)
![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mqyuq85t3dpinnhs7xfp.jpg)

cursor+trigger

Hareesh — Sun, 05 Oct 2025 16:43:21 +0000

Cursor + Trigger — SQL Practice
In this post, we’ll explore two powerful SQL concepts — Cursors and Triggers — with complete examples that you can run directly in Oracle LiveSQL.

CURSOR — Process Cursor with Condition
Problem Statement:

Create a cursor that displays employee names whose salary is greater than 50,000 from the Employee table.
CREATE TABLE Employee (
EmpID NUMBER PRIMARY KEY,
EmpName VARCHAR2(100),
Salary NUMBER(10,2)
);
INSERT INTO Employee VALUES (1, 'Arjun', 45000);
INSERT INTO Employee VALUES (2, 'Sneha', 52000);
INSERT INTO Employee VALUES (3, 'Kiran', 60000);
INSERT INTO Employee VALUES (4, 'Meena', 48000);
COMMIT;
SET SERVEROUTPUT ON;

DECLARE
v_EmpName Employee.EmpName%TYPE;
v_Salary Employee.Salary%TYPE;
CURSOR emp_cursor IS
SELECT EmpName, Salary
FROM Employee
WHERE Salary > 50000;
BEGIN
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;
/

*TRIGGER *— AFTER INSERT Trigger (Student Table)
Problem Statement:

Whenever a new student is added to the Students table, automatically insert a log entry into the Student_Audit table to keep track of the registration.
CREATE TABLE Students (
StudentID NUMBER PRIMARY KEY,
StudentName VARCHAR2(100),
Course VARCHAR2(100)
);
CREATE TABLE Student_Audit (
AuditID NUMBER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
StudentID NUMBER,
StudentName VARCHAR2(100),
ActionTaken VARCHAR2(100),
ActionDate DATE
);
CREATE OR REPLACE TRIGGER trg_AfterStudentInsert
AFTER INSERT ON Students
FOR EACH ROW
BEGIN
INSERT INTO Student_Audit (StudentID, StudentName, ActionTaken, ActionDate)
VALUES (:NEW.StudentID, :NEW.StudentName, 'New Student Registered', SYSDATE);
END;
INSERT INTO Students (StudentID, StudentName, Course)
VALUES (1, 'hareesh', 'Computer Science');
COMMIT;
SELECT * FROM Student_Audit;

Getting Started with SQL: My First Hands-On Experience

Hareesh — Mon, 25 Aug 2025 16:06:32 +0000

Over the past few days, I started learning SQL (Structured Query Language) and performed some of the most essential operations that every beginner should know. Databases power almost every application we use today, and SQL is the language that helps us communicate with them.
I practiced queries on a simple Students–Courses database and here’s what I tried:

Creating Tables (DDL) I started with the CREATE TABLE command to define the structure of my tables. For example: CREATE TABLE Faculty ( FacultyID INT PRIMARY KEY, FacultyName VARCHAR2(100) NOT NULL, Dept VARCHAR2(50), Email VARCHAR2(100) UNIQUE ); This helped me understand how to set primary keys, constraints, and column types.
Inserting Data (DML) Next, I used the INSERT INTO statement to add records into my tables. For example, I added some students into different departments. INSERT INTO Students (StudentID, Name, Dept, DOB, Email) VALUES (1, 'Saifulhaq', 'CSBS', TO_DATE('13-12-2006','DD-MM-YYYY'), 'itsaifulhaq@gmail.com');
Altering Tables I learned how to modify table structures using the ALTER TABLE command. For instance, I added a phone number column: ALTER TABLE Students ADD PhoneNo VARCHAR2(10);
Using Functions in SELECT I also explored SQL functions to manipulate and display data. Example: SELECT UPPER(Name) AS StudentName, LENGTH(Email) AS EmailLength FROM Students; This query shows student names in uppercase and calculates the length of their email IDs.
Aggregate Functions SQL makes it easy to calculate statistics. I tried: SELECT AVG(Credits) AS AvgCredits FROM Courses; SELECT COUNT(*) AS TotalStudents FROM Students;
Joins Finally, I experimented with joins to combine data from multiple tables: SELECT s.Name, c.CourseName, e.Grade FROM Students s JOIN Enrollments e ON s.StudentID = e.StudentID JOIN Courses c ON e.CourseID = c.CourseID; This lists all students with the courses they’re enrolled in and their grades. Final Thoughts 💡 Writing and executing these SQL queries gave me a solid understanding of how relational databases work. It’s one thing to learn the theory, but actually running queries and seeing the results makes it click much faster. I’ll be sharing more of my learning journey soon — especially as I explore advanced SQL queries and dive deeper into database design.
Thank you @santhoshnc sir for your valuable guidance...