DEV Community: CHINMAYA PRADHAN

Day 6 of DevOps Journey: Diving Deep into Node.js and Express.js for Backend Development

CHINMAYA PRADHAN — Thu, 03 Jul 2025 16:45:53 +0000

As I continue on my DevOps journey, today marked an important step: understanding the backend development stack, specifically Node.js and Express.js. While I had already finalized the tech stack and even completed the frontend of my mini social media application, backend development was an area I hadn’t yet explored in depth.

📌 Why Node.js and Express.js?
In the modern web development ecosystem, Node.js is widely adopted for its event-driven, non-blocking I/O model, which makes it lightweight and efficient, ideal for building scalable network applications. Express.js, built on top of Node.js, is a minimal and flexible web application framework that provides a robust set of features for web and mobile applications.

Since the aim of this journey is not just to build, but to learn the internals and adopt the right practices from a DevOps standpoint, getting a proper understanding of backend technologies was crucial before proceeding with implementation.

🧠 What I Did Today
Today was completely dedicated to learning. Here's how I structured my time:

✅ 1. Studied the Fundamentals

Understood what Node.js is and how it works under the hood.
Learned about asynchronous programming in JavaScript and how it benefits backend services.

✅ 2. Explored Express.js

Got familiar with the structure of an Express.js application.
Learned how routing, middleware, and error handling works.
Set up a basic server to test concepts locally.

✅ 3. Understood REST APIs

Learned the principles of RESTful API design.
Focused on how to create GET, POST, PUT, and DELETE routes to handle CRUD operations—something essential for the social media app.

✅ 4. Experimented with Tools

Explored Postman for API testing.
Installed and tested Nodemon for hot-reloading during development.

🔍 Why This Step Matters in My DevOps Learning Path
DevOps is not just about CI/CD pipelines and Kubernetes, it starts from understanding the architecture of the systems you're deploying. If I don’t know how a backend works, how can I monitor, scale, or secure it?

By learning Node.js and Express.js, I’m laying the groundwork for:

Writing modular, testable backend code.
Implementing scalable services that can later be containerized and deployed.
Integrating backend APIs with frontend seamlessly.

🚀 What's Next?
Now that I’ve gained enough foundational knowledge, tomorrow I’ll start writing the backend for my application. I’ll structure routes, connect with PostgreSQL (as planned earlier), and begin implementing authentication and user management features.

Day 5 of DevOps Journey: Designing the Database for the Social Media App

CHINMAYA PRADHAN — Wed, 02 Jul 2025 14:33:39 +0000

Over the past few days, I have been documenting my DevOps journey as I build a full-fledged Social Media Application from scratch. The idea is not only to develop the app but to gain a deep understanding of how DevOps fits into the lifecycle of modern applications, from development to deployment and maintenance.

Here’s what I’ve accomplished so far:

✅ Designed the complete UI/UX for the frontend
✅ Set up the backend framework using Node.js and Express.js
✅ Structured the project for scalability and modularity

Today, I moved on to an essential part of the application, the Database.

🧩 Why PostgreSQL?
When choosing the database for this social media platform, I opted for PostgreSQL. Here’s why:

Relational Model: Perfect for managing structured data like users, posts, comments, etc.
ACID Compliance: Ensures data integrity across all transactions.
Extensibility: Supports JSON, full-text search, and custom functions.
Community & Ecosystem: A widely supported, open-source option with excellent tooling.

🛠️ Database Architecture
The core components of any social media app involve user interactions, posts, comments, likes, notifications, and relationships (followers/following). Below is a simplified breakdown of the schema I designed:

🧑‍🤝‍🧑 Users Table
Column -> Type -> Description
id-> UUID-> Primary Key
username-> VARCHAR-> Unique username
email-> VARCHAR-> User's email address
password-> VARCHAR-> Hashed password
profile_pic-> TEXT-> URL to profile picture
created_at-> TIMESTAMP-> Timestamp of registration

📝 Posts Table
Column-> Type-> Description
id-> UUID-> Primary Key
user_id-> UUID-> Foreign Key (users)
caption-> TEXT-> Post content
image_url-> TEXT-> Optional media
created_at-> TIMESTAMP-> Time of post creation

💬 Comments Table
Column-> Type-> Description
id-> UUID-> Primary Key
post_id-> UUID-> Foreign Key (posts)
user_id-> UUID-> Foreign Key (users)
text-> TEXT-> Comment text
created_at-> TIMESTAMP-> Time of comment creation

❤️ Likes Table
Column-> Type-> Description
user_id-> UUID-> Foreign Key (users)
post_id-> UUID-> Foreign Key (posts)
created_at-> TIMESTAMP-> Time of like action

🔔 Notifications Table (Future Scope)
The notification system will handle alerts for likes, comments, and new followers.

🔗 Relationships & Indexing
I ensured to:

Set up foreign key constraints to maintain referential integrity.
Add indexes on frequently queried fields like username, post_id, and user_id to boost performance.
Consider cascading deletes/updates where necessary (e.g., deleting a post also deletes its comments and likes).

🔧 Tools Used

PostgreSQL for database engine
pgAdmin for visualizing and testing schemas
Knex.js / Sequelize (TBD) for integrating with the Node.js backend

📌 Next Steps
Now that the database schema is in place, the next phase involves:

Connecting the backend (Express.js) to the PostgreSQL database
Building out the API endpoints for user registration, posting, commenting, etc.
Writing migration scripts and seeding dummy data for testing

🌟 Key Takeaways

A well-thought-out database schema is foundational to any scalable application.
PostgreSQL offers the perfect mix of structure and flexibility for social media-type apps.
Designing tables and relationships early saves hours of debugging later in the DevOps lifecycle.

Day 4 of DevOps Journey: Frontend Completion & Backend Kickoff

CHINMAYA PRADHAN — Tue, 01 Jul 2025 13:56:11 +0000

Today marks a significant milestone in my DevOps journey as I successfully wrapped up the entire frontend development of the project. The UI has now taken its final shape, providing a responsive and intuitive user experience that aligns with the application’s core purpose. With the frontend foundation in place, it’s time to shift gears and dive into the backend development phase.

✅ Frontend Phase: Completed
After days of planning, wireframing, and coding, the frontend is now complete. I focused on building a clean, responsive, and modular interface that ensures seamless user interactions. Leveraging modern web development practices, the UI is now ready to communicate with the backend and support future integrations.

🔧 Backend Kickoff: Tech Stack Selection
To build a scalable and efficient backend, I’ve chosen:

Framework: Express.js
Runtime: Node.js
Database: PostgreSQL

These technologies were selected for their reliability, community support, and ease of integration. Express.js offers the flexibility needed to build RESTful APIs quickly, while PostgreSQL provides a robust relational database system to manage structured data effectively.

🏗 Project Structure Initialization
The initial structure of the backend project has been set up with a clear folder hierarchy and code organization. This includes:

API route definitions
Middleware setup
Configuration for environment variables
Basic database connection logic

Laying this foundation is crucial to ensure that the codebase remains maintainable and scalable as the project grows.

📅 From this point on, the focus will be on building API endpoints, establishing secure communication between the frontend and backend, and integrating the PostgreSQL database. The journey continues with hands-on learning, architectural planning, and iterative development.

Stay tuned for more updates as I continue building this application end-to-end while learning the core principles of DevOps through real-world practice.

Day 3 of DevOps Journey: UI Milestone Achieved, Backend Planning Begins

CHINMAYA PRADHAN — Mon, 30 Jun 2025 14:05:59 +0000

🎯 Progress Update:
Today marks the third day of my DevOps journey, and I’m excited to share a key milestone, the completion of the frontend UI design for my application. Although the process was quite time-consuming, especially given my limited experience with frontend development, I’m proud to say that the interface is now fully functional.

Designing the frontend using ReactJS presented its own set of challenges. It required considerable time and effort to understand layout structures, component communication, and styling practices. In parallel, I also worked on the Software Engineering documentation, including system design, architecture, and user flow, which added to the overall workload but significantly helped me structure the system better.

I’ve included both the documentation and screenshots of the application below to showcase the current progress. The application is not only designed but also responsive and ready for integration.

Documentation Link: https://docs.google.com/document/d/1ia_EqDI9kaNc8GWJ8hM-g-hk-S5Vsgep__eZ-CLiizg/edit?usp=sharing

Screenshots:

🔧 What’s Next?
Now that the frontend is in place, it’s time to move to the next phase: backend development.

I am currently deciding between two frameworks:

FastAPI (Python): Known for its speed and modern features.
Express.js with Node.js: A powerful choice that aligns well with my frontend stack in ReactJS.

Given the natural compatibility and seamless integration with React, I’m currently leaning toward Express.js and Node.js for building the backend. This will allow for better control over API development and easier handling of frontend-backend communication.

🌱 Reflections & Learnings
This phase of the project has reinforced an important lesson: Consistency and patience pay off. Even with limited frontend experience, I pushed through the challenges, and the results are rewarding. Writing technical documentation alongside development has also improved my understanding of software systems holistically.

📌 What’s Coming Next?

Set up the backend framework and folder structure
Start designing RESTful APIs
Connect the backend to the React frontend
Begin testing user authentication and data flow

Thanks for following along with my DevOps journey. There’s so much more to learn and build, and I’m excited for the road ahead. Let’s learn, build, and grow together! 🌟

Day 2 of DevOps Journey: Starting with Software Engineering and Frontend Design

CHINMAYA PRADHAN — Sun, 29 Jun 2025 12:31:08 +0000

Wait, wait, wait… Before jumping into building an application, there’s a crucial question that hit me today:

“How can I start developing a social media application without following the Software Development Life Cycle (SDLC)?”

The truth is, I can’t and I shouldn’t.
Just like any structured system, every successful project begins with a process. And that process in software development is SDLC, the backbone of building scalable, maintainable, and reliable applications.

So, before diving into code and features, I took a step back and realigned myself with the Software Engineering principles. It’s important to understand the stages of planning, requirement gathering, designing, developing, testing, deployment, and maintenance. With that mindset, I began my Day 2 by focusing on the design phase, particularly the Frontend UI/UX of the application.

🎨 What Am I Building?
I’m working on the UI/UX design of a social media application, my goal is to create a platform that’s clean, intuitive, and more focused than Instagram in terms of user experience. Right now, I’ve structured two main components of the frontend:

🏠 Homepage (Public Feed)

The homepage is the heart of the platform where users can:

Scroll through public posts made by other users.
Like and comment on posts they find interesting.
Enjoy a minimal and distraction-free interface with easy navigation and clean design.
Each post card includes:

The user’s profile image and name
Image or content shared
Interactive buttons for likes and comments
A compact comment section with a reply option

The idea is to keep it clean and better structured than existing platforms, allowing users to focus more on the content and less on the clutter.

👤 User Profile Page

The profile page is where users can:

View all their uploaded posts in a neatly organized grid.
Edit or delete their own posts.
See the total number of posts, likes, and interactions.
Possibly add a bio or profile image in later versions.

This page will serve as the personal space for each user, giving them full control over their content and profile presentation.

🧱 Why UI/UX First?
Starting with UI/UX allows me to:

Visualize the user flow
Plan backend APIs and database structure better
Break down features into manageable microservices or components for DevOps pipeline
Maintain modularity and scalability, which are crucial for any cloud-native application

This approach ensures that the rest of the system , from backend to deployment, can be built in a well-organized, modular, and scalable fashion. The frontend serves as the blueprint for the business logic and infrastructure to follow.

🔜 What’s Next?
Once the UI/UX part is finalized, I’ll:

Begin backend development using FastAPI
Set up a CI/CD pipeline for automated deployment
Containerize the application using Docker
Eventually deploy it to Kubernetes on a cloud platform

This is just the beginning, but every solid system starts with the right planning.
Day 2 has been all about design thinking, aligning with SDLC, and laying the visual foundation for a meaningful application.

Stay tuned for Day 3 where I’ll dive into building the professional document for the application.
Until then, build smart, plan smarter.

🚀 Day 1 of Learning DevOps: Laying the Foundation

CHINMAYA PRADHAN — Sat, 28 Jun 2025 04:53:41 +0000

DevOps may sound like a simple blend of “Development” and “Operations,” but in reality, it encompasses a vast ecosystem, covering everything from deployment, maintenance, security, and scalability to modularity and continuous delivery.

However, before diving into managing these aspects, it’s essential to understand how a system is actually built. Without knowing the inner workings of a system, managing and optimizing it becomes abstract and inefficient.

🎯 Week 1 Goal: Build a Mini Social Media App
To build a strong foundation, this week’s objective is to develop a basic social media application. This will include:

Frontend Interface: A simple user-friendly UI.
Backend: To handle routing, business logic, and APIs.
Business Logic Layer: Where core functionality is implemented.
Database Integration: For storing and retrieving user data. The purpose of this exercise is to develop a clear understanding of the entire flow: how the frontend communicates with the backend, how APIs are structured, and how databases are connected and managed. Gaining this hands-on knowledge is critical before stepping into DevOps tools and automation.

🛠️ For Beginners & Co-Learners
If you’re learning alongside and have no prior experience in web development, spend the next 2–3 weeks focusing on:

Basics of HTML, CSS, and JavaScript
Backend development (FastAPI or Java or Node.js)
Understanding HTTP & API calls
Secure communication (HTTPS, tokens, authentication)
Database connectivity and management
Deployment basics This groundwork will make your DevOps journey smoother and more impactful.

📌 Daily Progress & Community Sharing
I’ll be sharing daily progress updates and learnings on Medium, Hashnode and Dev.to.

Feel free to follow along, give feedback, or ask questions if you’re on a similar path. Let’s grow together and make DevOps easy to understand and implement from the ground up!

My DevOps Journey Begins: From Curiosity to Commitment

CHINMAYA PRADHAN — Fri, 27 Jun 2025 03:40:03 +0000

📍 Introduction: What Is DevOps, Really?

At first glance, DevOps might seem like a simple mashup of Development and Operations. But as I started exploring this domain, I realized it’s much more than just deploying code or using a bunch of tools like Docker, Kubernetes, Jenkins, or Ansible.

In fact, no one can truly define DevOps in one sentence. It’s a culture, a mindset, a collection of practices, and to me, it’s the practical implementation of everything we learn in Software Engineering.

From SDLC, project management, security, infrastructure, automation, and beyond, DevOps is the hands-on version of it all. It’s not about just knowing tools. It’s about understanding why we use them, and how they fit into a larger system that drives real-world impact.

🧠 Why DevOps Matters (Now More Than Ever)

Everyone is talking about AI/ML taking over jobs. But ask yourself, how is that AI built? Who deploys it? Who ensures it doesn’t break under load? Who scales it when millions of users interact with it?

That’s right. Behind every AI, every web app, every mobile app, there’s a system keeping it alive, secure, and scalable. That’s DevOps.

Even when a new Python library drops, someone needs to update the CI/CD pipelines, repackage containers, or validate version compatibility. It’s a constant process of learning and evolving, just like life itself.

🎓 The Transition: From College to Corporate

As someone who just completed their Bachelor’s in Computer Science, I’m standing at the threshold of the real world. This marks the beginning of my professional DevOps journey. But before I take this leap, here are some principles I’ve embraced:

✅ Own your work : take full responsibility for what you build or break.
📚 Never stop learning : tech evolves fast; we must evolve faster.
👨‍👩‍👧‍👦 Value relationships : family and friends > corporate roles.
⏳ Act now: waiting too long often means never doing it.
🧍‍♂️ Take initiative: if you don’t move forward, you’ll remain stuck.

🛠️ My Initial Misconceptions

When I first heard about DevOps, I thought:

“Just learn Docker, Jenkins, Terraform, Ansible and you’re a DevOps engineer.”

But following thought leaders like @savinderpuri and @TechWorldWithNana, I quickly realized tools are just the beginning.

“Everyone can learn the tools. What sets you apart is how you solve real problems using them.”

📅 The Journey Begins: Weekly & Daily Updates

This is just the beginning of my journey toward becoming part of the top 1% in the DevOps field. From now on:

Weekly updates will be posted on LinkedIn.
Daily insights and learning logs will be shared on Medium, Hashnode and Dev.to
If you’re someone who’s just starting or even looking to transition into DevOps, feel free to follow along or co-learn with me.

💬 Final Thoughts

DevOps is not a destination, it’s a continuous journey of curiosity, learning, experimenting, failing, and growing. This blog is the first step, and many more will follow.

Whether you’re a beginner, a student, or a professional, remember:

“You don’t need to be great to start, but you need to start to be great.”

Let’s learn, build, break, fix, and grow together.

📌 Stay tuned for next week’s post: “Choosing My DevOps Tech Stack, What, Why & How”