DEV Community: Pooja Bhavani

The Only Production Dashboard That Refuses to Serve Coffee

Pooja Bhavani — Fri, 03 Apr 2026 07:53:08 +0000

This is a submission for the DEV April Fools Challenge

What I Built

You know what the cloud-native ecosystem was missing? Production-grade observability tooling for tea.

Introducing HTCPCP/2.0 Enterprise — a fully interactive Kubernetes-style monitoring dashboard for your imaginary tea brewing cluster. It has real-time log streaming, pod health indicators, temperature telemetry, request traces, autoscaling metrics, and a Deploy to Production button that always returns HTTP 418.

Always. That's not a bug. That's RFC compliance.

In 1998, a group of engineers led by Larry Masinter published RFC 2324 — the Hyper Text Coffee Pot Control Protocol (HTCPCP). It defined a new internet protocol for controlling coffee pots over a network, and inside it, a new HTTP status code: 418 I'm a Teapot, returned whenever a teapot is asked to brew coffee. It was an April Fools' joke. Status 418 was a joke inside the joke.

Then the internet loved it so much it made it real. Node.js has it. Go has it. Python has it. So I built a full enterprise dashboard to honour it properly.

With Kubernetes pods.

Demo

https://pooja-bhavani.github.io/htcpcp-enterprise/

Code

https://github.com/pooja-bhavani/htcpcp-enterprise

How I Built It

I started with the most important architectural decision: what would an enterprise
cloud dashboard look like if it took RFC 2324 seriously?

The answer is: exactly like this. A dark-themed ops console. Kubernetes pod terminology.
Horizontal pod autoscaling for chamomile (bedtime approaching in the EU region).
An ingress controller blocking espresso machines on port 5000. A CI/CD pipeline that
throws CoffeeAttemptException at the brew step.

The UI was built mobile-first (lies — it was built for widescreen monitors because
that's where ops dashboards live), then I added a CRT scanline effect because nothing
says "production system" like mild visual artifacts.

The hardest part was writing the fake log messages. Each one needed to sound exactly
like a real Kubernetes log entry while being completely about tea. I'm proud of:

HPA: scaling chamomile replicas to 3 (bedtime approaching in EU region)

That one goes hard.

Prize Category

Best Ode to Larry Masinter — This entire project exists because of RFC 2324.
Larry Masinter and his co-authors gave the internet its most beloved useless status
code, and this dashboard is a monument to that gift. Every 418, every tea pod, every
I'm a Teapot modal — it's all for you, Larry.

Also submitting for Community Favorite because I believe in the people who will
recognise the 4m18s steep time and feel seen.

Built with: HTML, CSS, vanilla JS, RFC 2324, and a deep respect for intentionally
useless internet standards.

No coffee was brewed during the making of this project. Several attempts were made.
All returned 418.

Resurrecting the Internet's Past: Building a Modern Gopher Browser with Kiro

Pooja Bhavani — Fri, 05 Dec 2025 17:54:58 +0000

How I brought a 1991 protocol back to life in 6 hours using spec-driven development

https://modern-gopher.netlify.app/

also added a screen-recording for your reference

The Challenge

When I saw the Kiroween Hackathon's "Resurrection" category, I knew exactly what I wanted to build: a modern interface for the Gopher protocol. For those unfamiliar, Gopher was the dominant way to navigate the internet before the World Wide Web took over in the mid-90s. It's a text-based protocol from 1991 that's simpler, faster, and still has active servers running today—but accessing them requires special clients or command-line tools.

My goal? Make Gopherspace accessible to everyone through a beautiful, retro-futuristic web application.

Why Gopher?

Gopher represents a fascinating "what if" in internet history. It was cleaner, more organized, and arguably more user-friendly than early HTTP. But it lost the protocol wars to the World Wide Web. Today, there's a small but dedicated community keeping Gopherspace alive, hosting everything from personal blogs to Wikipedia mirrors.

The problem? There's no modern, user-friendly way to browse it. That's where my project comes in.

Enter Kiro: Spec-Driven Development

Rather than diving straight into code, I used Kiro's spec-driven development workflow. This was a game-changer. Here's how it worked:

Phase 1: Requirements

I started by defining what the browser needed to do. Using EARS (Easy Approach to Requirements Syntax), I created 8 major user stories with 40 acceptance criteria. For example:

User Story: As a user, I want to connect to Gopher servers and view their content, so that I can explore Gopherspace through a modern interface.

Acceptance Criteria:

WHEN a user enters a Gopher URL THEN the Web Interface SHALL establish a TCP connection to the specified server and port

WHEN the Web Interface receives a Gopher menu response THEN the Web Interface SHALL parse the menu according to RFC 1436 format

This structured approach forced me to think through every feature before writing a single line of code.

Phase 2: Design

Next, Kiro helped me create a comprehensive design document. The most interesting part? Correctness properties—formal statements about what the system should do that can be tested with property-based testing.

For example:

Property 2: Gopher menu round-trip consistency
For any valid Gopher menu structure, serializing to RFC 1436 format then parsing should produce an equivalent menu structure with all fields preserved.

I ended up with 19 of these properties. They're like unit tests on steroids—instead of testing specific examples, they verify behavior across infinite inputs.

Phase 3: Implementation Plan

Kiro generated a task list with 14 major tasks, each traceable back to specific requirements. This became my roadmap:

Set up project structure

Implement Gopher protocol handler

Build React frontend

Add bookmarks and history

Create retro UI theme

And so on...

Phase 4: Building

With the spec complete, implementation was surprisingly smooth. I knew exactly what to build and why. No scope creep, no "should I add this?" moments—just focused execution.

The Tech Stack

Backend:

Node.js + Express

Raw TCP socket connections (Gopher uses TCP, not HTTP!)

Custom RFC 1436 parser

Frontend:

React 18 + TypeScript

Vite for blazing-fast builds

Pure CSS for that retro aesthetic

Special Sauce:

Web Audio API for retro computer sounds

Service Workers for PWA/offline support

LocalStorage for bookmarks and history

The Features

Full Gopher Protocol Support

The browser handles all major Gopher item types:

Text files (type 0)

Directories (type 1)

Search servers (type 7)

Binary files (types 9, g)

HTML links (type h)

And more!

Three Retro Terminal Themes

I added a theme switcher with three authentic terminal color schemes:

Green phosphor (classic terminal)

Amber (warm 80s vibes)

White (high contrast monochrome)

Every UI element—buttons, text, borders, even the loading spinner—adapts to the selected theme. It's like having three different vintage computers in one app.

Authentic Retro Sounds

Boot-up sound when you first open the app (like an old PC powering on)

Modem sound when connecting to servers (that classic dial-up nostalgia)

These were created using the Web Audio API—no audio files needed!

Modern Conveniences

Despite the retro aesthetic, it has modern features:

Bookmark management with localStorage

Navigation history (last 50 sites)

Back button navigation

Search functionality

PWA support (install it like a native app!)

Responsive design (works on mobile)

The UI

The interface honors Gopher's history while feeling modern:

CRT-style scanlines

Glow effects on interactive elements

Smooth animations

ASCII art logo

Monospace fonts throughout

What I Learned

Spec-Driven Development Works

I was skeptical at first—90 minutes of planning before writing code? But it paid off massively. I never got stuck wondering "what should I build next?" The spec was my north star.

Correctness Properties Are Powerful

Property-based testing catches bugs that unit tests miss. For example, my "menu round-trip" property found an edge case with empty selectors that I never would have thought to test manually.

Constraints Breed Creativity

The Gopher protocol is incredibly simple compared to HTTP. This constraint forced me to focus on UX and aesthetics rather than complex features. Sometimes less is more.

Retro Can Be Modern

The retro aesthetic isn't just nostalgia—it's functional. The high-contrast colors, simple layouts, and clear typography make the app highly usable. Plus, it's just fun!

Try It Yourself

The project is open source and ready to run:

GitHub: https://github.com/pooja-bhavani/Kiroween-Challenge

Try these Gopher URLs:

gopher://gopher.floodgap.com - Most popular Gopher server

gopher://gopherpedia.com - Wikipedia on Gopher!

gopher://gopher.quux.org - Classic Gopher content

The Bigger Picture

This project isn't just about Gopher—it's about preserving internet history and making it accessible. The early internet had a charm and simplicity we've lost. Projects like this remind us that "dead" technologies often have valuable lessons to teach.

Plus, it's a testament to what you can build in a weekend with the right tools and approach. Spec-driven development with Kiro turned what could have been a chaotic hackathon scramble into a structured, enjoyable building experience.

What's Next?

I'm considering adding:

Gopher+ protocol support

Custom theme creator

Browser extension version

Gopher server hosting capabilities

But for now, I'm just excited to share this with the world and see people explore Gopherspace again.

Conclusion

Building the Gopher Browser taught me that:

Old technologies deserve modern interfaces

Spec-driven development is worth the upfront investment

Retro aesthetics can be both beautiful and functional

You can build something meaningful in just 6 hours

If you're interested in internet history, retro computing, or just want to see what the web looked like before the web, give it a try. And if you're building something complex, consider using specs—your future self will thank you.

Technical Deep Dive (For the Curious)

How Gopher Works

Gopher is beautifully simple:

Client connects to server via TCP (usually port 70)

Client sends: selector\r\n

Server responds with either:

A menu (tab-delimited lines)

Plain text content

Connection closes

That's it! No headers, no cookies, no JavaScript. Just pure content.

The Parsing Challenge

Gopher menus are tab-delimited:

Type + Display + TAB + Selector + TAB + Host + TAB + Port

For example:

0About this server /about.txt gopher.example.com 70
1Documents /docs gopher.example.com 70

My parser had to handle:

Different line endings (CRLF vs LF)

Missing fields

Invalid item types

Empty selectors

Special characters

The round-trip property test caught several edge cases I missed!

The Audio Challenge

Creating retro sounds without audio files was fun. The boot-up sound uses:

Low frequency beep (100 Hz)

Rising tone (100 Hz → 800 Hz)

High frequency beep (1200 Hz)

All synthesized in real-time with the Web Audio API!

The Theme System

CSS variables made theme switching trivial:

.app.theme-green {
--primary-color: #00ff00;
--bg-color: #000;
}

.app.theme-amber {
--primary-color: #ffb000;
--bg-color: #000;
}

Every component uses var(--primary-color) instead of hardcoded colors. Change the class, change the theme!

GitHub: https://github.com/pooja-bhavani/Kiroween-Challenge
Built with: Kiro, React, Node.js, TypeScript, and lots of ☕

Understanding AWS Storage & Recovery Services: A Complete Guide

Pooja Bhavani — Tue, 18 Nov 2025 19:42:05 +0000

When operating in the cloud, data storage and recovery are among the most crucial components. Amazon Web Services (AWS) offers a comprehensive array of services designed to meet various storage requirements, ranging from basic object storage to fully managed file systems, hybrid storage, and disaster recovery solutions. In this blog, we’ll explore key AWS services like AMI, S3, EBS, EFS, AWS Backup their purpose, use cases, and when to choose which.

Amazon Machine Image (AMI)

Let’s understand what is AMI.

So, AMI Amazon Machine Image is an a pre-configured template used to create your EC2 instance. It contains the operating system, application server, and applications required to launch an instance. Instead of manually configuring each instance, you can use an AMI Amazon Machine Image to launch a server with all the necessary software and configurations already set up.

Types of AMI’s:

AWS-provided AMIs (Amazon Linux, Ubuntu, Windows)

Marketplace AMIs (3rd-party software)

Custom AMIs (your own configured servers)

Amazon Elastic Block Store (Amazon EBS)

Amazon Elastic Block Store (Amazon EBS) provides scalable, high-performance block storage can attach to Amazon EC2 instances and data is divided into blocks and stored. It is designed for low-latency, high-performance workloads where applications need fast read/write access to blocks of data.

Key features of EBS

Block-Level Storage

Data is divided into blocks and stored.
The application can read/write specific blocks directly, making it ideal for databases and file systems.

Persistence

Here the data persists even if you stop or terminate the EC2 instance.
Snapshots (point-in-time backups) can be taken and stored in S3.

EC2 Attachment

Each EBS volume can be attached to an EC2 instance.
One volume one EC2 at a time (but you can detach and attach elsewhere).

Durability & Availability

Data is automatically replicated within an Availability Zone (AZ).
It ensures high durability and protection against hardware failures.

Use cases of EBS

Databases

MySQL, PostgreSQL, MongoDB, Oracle, etc. need block storage for fast transactions.
EBS provides low latency and high throughput.

Boot Volumes

EC2 instances typically boot from an EBS root volume.
You can choose pre-built AMIs with EBS as the root storage.

The difference between EBS root volume and EBS?

Root Volume

Root volume is essential for launching and running the EC2 instance
By default if you terminate the root volume will also get deleted with the instance (Is an temporary storage).
Root volumes can be either instance store (ephemeral, data lost on termination) or EBS-backed.
Root volumes are used for the operating system boot files, and essential system components.
Here the root volume size is limited by the instance type.

EBS (Elastic Block Store)

Here EBS volume persists/stays even if you terminate the instance, but you can also choose to delete them.
EBS volumes provide extra storage for applications, data, and other files.
EBS volumes persist even if the instance is stopped or restarted.
It can be scaled up or down when needed.
It is used for application data, databases, and other files that need persistent storage.
It offers more flexibility for scaling storage capacity and adjusting performance

EFS (Elastic File System)

Amazon EFS (Elastic File System) is a serverless, scalable, and cloud-based file storage service for AWS compute services and on-premises resources. It provides a shared file system that can be mounted simultaneously by multiple EC2 instances or containers, making it ideal for workloads that require concurrent access to the same data.

Use case:

Used for applications that need to share files across multiple compute instances.

Provides a common storage space for shared web content.

Offers shared storage for training and running machine learning models.

Key Features of EFS:

Elastic and Scalable:

Automatically grows and shrinks as you add or remove files.

No need to provision storage in advance.

Managed Service:

Fully managed by AWS — no hardware or infrastructure to maintain.

Shared Access:

Multiple instances or containers can access the same file system concurrently using the NFS protocol.

High Availability and Durability:

Data is stored across multiple Availability Zones (AZs) for redundancy.

Performance Modes:

General Purpose: For most applications (low-latency access).

Max I/O: For large-scale, highly parallel workloads.

Storage Classes:

Standard: For frequently accessed files.

Infrequent Access (EFS IA): Cost-effective for rarely accessed files.

Integration with AWS Services:

Works with EC2, ECS, Lambda, and other services requiring shared file storage.

Amazon Simple Storage Service (Amazon S3)

Amazon S3 is a public cloud storage service in AWS that offers scalability, high availability, security, and strong performance. It provides object-based storage, where data is stored inside S3 buckets in distinct units called objects, rather than as traditional files.

Key Points:

Each bucket must be created in a specific region.

Bucket names must be globally unique across all regions and accounts.

Maximum storage of S3 Bucket is 5TB.

Use Cases:

Backup and Storage – Store and manage critical data securely.

Data Lakes and Analytics – Manage, analyze, and protect large amounts of data for cloud-native and mobile applications.

Disaster Recovery – In case a region goes down it replicates data across regions to ensure availability.

Archiving – You can archive and retrieve infrequently accessed data using cost-effective storage classes.

Types of S3 Storage Classes

S3 Standard:

This is the general-purpose storage for frequently accessed data it offers high durability, availability, and performance with low latency and high throughput. It is suitable for websites, content distribution, big data analytics, mobile and cloud applications.

S3 Intelligent-Tiering:

This class automatically moves objects between frequent and infrequent access tiers. It moves objects between frequent, infrequent, and archive instant access tiers based on monitoring, without performance impact or retrieval charges.

Cost: Optimizes cost automatically, minimal monitoring fee.

S3 Standard-Infrequent Access (S3 Standard-IA):

Designed for data accessed less frequently but requires rapid access when needed. It offers lower storage costs than S3 Standard but higher retrieval costs. Used for backups, disaster recovery, long-term storage.

Cost: Lower storage cost than Standard, but retrieval has a fee.

S3 One Zone-Infrequent Access (S3 One Zone-IA):

Similar to S3 Standard-IA but stores data in a single Availability Zone instead of multiple zones, but offers lower costs. Use Case – Secondary backups or easily re-creatable data.

Cost: Cheaper than Standard-IA, but lower redundancy.

S3 Glacier Instant Retrieval:

An archive storage class for data requiring immediate access, such as medical images or news media assets. It provides low-cost storage with millisecond retrieval times.

S3 Glacier Flexible Retrieval:

A low-cost archive storage class for long-term data archiving, like backups and disaster recovery. Retrieval times range from minutes to hours depending on retrieval option.

S3 Glacier Deep Archive:

The lowest-cost storage class for long-term archiving, suitable for data accessed once or twice a year, such as compliance archives. Retrieval times are typically within 12 hours.

Cost: Lowest-cost storage for long-term retention.

AWS Backup

AWS Backup is a fully managed service in AWS that helps you to centrally back up and restore your data across AWS services. It simplifies the process of protecting your applications and data by automating backup scheduling, retention management, and compliance monitoring.

Key Features of AWS Backup:

Centralized Backup Management:

Manage backups for multiple AWS services (like EBS, RDS, DynamoDB, EFS, FSx) from a single place.

Automated Backup Scheduling:

Define backup plans and policies to automatically take backups at specified times.

Retention and Lifecycle Management:

Set rules for how long backups should be retained and automatically transition older backups to cheaper storage classes.

Cross-Region and Cross-Account Backups:

Copy backups to other AWS regions or accounts for disaster recovery and compliance purposes.

Data Protection and Compliance:

Helps meet regulatory requirements by providing auditing, logging, and encryption for backups.

On-Demand Backups:

Create manual backups whenever needed, in addition to scheduled backups.

Empowering AI Conversations Using Redis 8 as a Real-Time Brain

Pooja Bhavani — Sat, 02 Aug 2025 09:17:08 +0000

This is a submission for the Redis AI Challenge: Real-Time AI Innovators.

What I Built

DevPrompt AI is a smart, lightweight AI assistant designed for developers and tech learners. It's a web-based tool where users can ask any question — technical or non-technical — and get instant responses powered by OpenAI's large language models.

Built using FastAPI + Redis + OpenAI API — this setup enables smart caching and real-time answers to your questions.

Demo

https://res.cloudinary.com/dvlvkkue3/video/upload/v1754125729/Screen_Recording_2025-07-31_at_10.47.40_PM_g0iibh.mov

How I Used Redis 8

It uses Redis 8 as the real-time caching layer to reduce API latency and cost by caching frequently asked queries and instantly serving them. This improves the user experience significantly by delivering results faster — especially for common queries.

The user sends a question to the FastAPI backend

The app checks Redis first (fastest!)

If not found, it fetches from OpenAI and caches it for future

And everything is now testable via Swagger Docs for easy dev/test!

If you're building with OpenAI + Redis, be sure to check your SDK version compatibility!

Thanks for this exciting opportunity!

StyleHub – Building a Fashion Storefront with Bolt-Powered Speed

Pooja Bhavani — Mon, 21 Jul 2025 05:17:30 +0000

This is a submission for the World's Largest Hackathon Writing Challenge: Building with Bolt.

During the World's Largest Hackathon, I challenged myself to create a full-fledged e-commerce platform with a sleek design, responsive layout, and modern developer tooling. The result? StyleHub — an online fashion store with a futuristic vibe, powered by React and styled with Tailwind CSS.

This project helped me explore new UI design patterns, refine my frontend skills, and experience what it feels like to ship a modern digital storefront in a fast-paced environment.

🛠️ What I Built

StyleHub

A e-commerce web app with the following features:

Fully responsive homepage with hero banner and featured categories
Navigation bar with routing to Home, Shop, Categories, Blog, Contact, and Login
Visually engaging product thumbnails using high-resolution images
Deployed on Netlify for global reach

🔗 Live Site
(https://stylehub-dev.netlify.app)

GitHub Repo
(https://github.com/pooja-bhavani/StyleHub)

⚡️ The Bolt Factor

I used AI suggestions from tools like GitHub Copilot to:

Refine my component structure
Implement responsive utility classes faster
Optimize the navigation bar and image gallery layouts
Debug tricky UI issues in minutes

These tools boosted my productivity and let me focus on creativity and UX.

Lessons Learned

Simplicity and speed in UI go a long way — Tailwind + component-driven design helped tremendously.
Previewing UI changes in real-time while deploying on Netlify was a game-changer.
The power of developer tools (like Bolt/Copilot) makes solo-hackathon projects feel collaborative.

What’s Next

StyleHub is currently frontend-only, but I'm planning to:

Add product filtering, sorting, and search
Connect it to a backend with user auth and product management
Add cart and payment integration

Thanks to the hackathon community and DEV for this opportunity!

Docker Series: Learn Docker from Scratch

Pooja Bhavani — Mon, 14 Jul 2025 09:09:16 +0000

This guide includes Docker installation, creating and optimizing Dockerfiles, pulling images, managing containers, working with volumes and networks, and troubleshooting commands — with real world examples using our base project — EasyShop

1. Installation for Each Platform

Linux (Ubuntu/Debian)

sudo apt update
sudo apt install docker.io -y
sudo systemctl enable docker
sudo systemctl start docker
docker --version

Mac & Windows

Visit the official Docs

Download Docker Desktop:

docker --version

2. Docker Architecture

Docker Client

The Docker Client (or Docker CLI Command Line Interface)) both are same it allows you to communicate with Docker Deamon . Here we can write commands like docker run, docker pull, docker build etc.

Docker Host

It is a Physical or Virtual Machine that runs the Docker Engine. It is the main environment provides that provides necessary resources (CPU, memory, storage, networking) to execute Docker containers.

What is dockerd?
dockerd is the Docker daemon which runs in the background. It listens for Docker API requests and handles tasks like:

Building Images
Running and Stoping Containers
Managing Networks and Volumes
You can check the status using:

systemctl status docker

DockerHub

It is an cloud-based public registry where you can store your docker images.

You can push your images to Docker Hub and pull them when needed for development or deployment.

Docker Hub integrates seamlessly with Continuous Integration and Continuous Delivery (CI/CD) pipelines, and allows you for automated builds and deployments.

3. Pulling Docker Images

The commands are used for pulling docker images from Artifact registries like DockerHub

docker pull nginx
docker pull mongo
docker pull <your dockerhub imagename>

4. Checking Stats of running Containers

docker stats

5. Images and Container Management

Images
What are docker Images?

Images are Executable Packages that contains dependencies (e.g: Node.js, Python), Configuration (e.g: environment variables), software packages and Application code)for the purpose of creating containers.

Container
What is container ?

A container is a lightweight, standalone unit of software that includes everything required to run an application including code, runtime, and dependencies ensuring it runs quickly and reliably across different computing environments.

Commands:
To get the list of Docker Images

docker images

To get the list of only running containers

docker ps

To get the list of all running and stopped containers

docker ps -a

To Stop the container


docker stop <container_id or container name>

To Remove Container

docker rm <container_id or container name>

To remove the image

docker rmi <image_id>

7. Troubleshooting Commands

To Check container logs

docker logs <container_id or container name>>

To Inspect containers/images

docker inspect <container_id or image_id>

To Enter container shell/ your container

docker exec -it <container_id> /bin/bash

To check Disk usage and cleanup

docker system df
docker system prune

8. Builder Cache & Clean Images

Each instruction in the Dockerfile adds a layer to the image. The intermediate layers are generated during the build process. When we rebuild the image without making any changes to the Dockerfile or source code, Docker can reuse the cached layers to speed up the build process.

To clean cache:

docker builder prune

To avoid caching during build


docker build --no-cache -t easyshop .

Dockerfile Instruction Explanation with Layer-by-Layer Breakdown & Caching Tips

FROM node:18

Here we define the base image that includes everything needed to run apps Eg: Node:18 image is pre-installed. It’s cached unless you change the Node version. Always use a specific version like node:18 to ensure consistency and Docker’s layer caching.

WORKDIR /app

This sets the working directory inside the container to /app. All subsequent commands will run from this location. It doesn’t change often, so it's always cached and adds to Dockerfile readability and structure.

COPY package*.json ./

This step copies only package.json and package-lock.json. It’s one of the most important steps for caching because dependencies don’t change as often as your application code. Keeping this separate helps Docker cache the npm install layer effectively.

RUN npm install

This installs all the dependencies listed in the package files. If the previous layer is unchanged, Docker reuses this cached layer and skips re-installing, and significantly speeds up builds.

COPY . .

Now that dependencies are installed, we copy rest of the app files from source to destination which is from host system to container. This ensures that if you change only your app code, Docker won’t repeat the installation step just this one gets rebuilt. That’s the whole idea behind leveraging Docker’s layer caching.

EXPOSE 5000

This exposes port 5000 so others know which port the app is running on. It doesn’t affect caching or container behaviour directly, but is useful for documentation and when using Docker Compose.

CMD [“node”, “index.js”]

This is the default command that runs when the container starts and you can override this command. It usually remains unchanged and gets cached normally.

9. Volumes — Persistent Storage

What are Volumes? Why Use Docker Volumes?

Volumes provide a way to persist the data outside the containers file system making it available even after container restarts or deletions. So it can be backed up or shared. It allows multiple containers to share same data and ensures that the data persists even if the containers are stopped or removed.

The path for volumes is /var/lib/docker/volumes/

Commands:
To create volume

docker volume create <volume name>

To run a container and mount the volume to /app/data inside the container


docker run -v $(pwd)/data:/app/data <image name>

10. Docker Networks

What are Docker Networks?

Docker provides In-built networking features enabling secure and efficient communication between containers and the host machine. It provides isolation between containers, allowing you to control which containers can communicate with each other.

Types of Networks

Bridge Network

It is a default network using this you can bind the host and container port. It creates a virtual bridge on the host to connect containers.

Host Network

This network is to run the container on same network where your host system is running that means both the ports are auto-mapped. If we give this network then we don’t need to do port mapping.

Custom Bridge Network (User-Defined Network)

That means to create your own secure network and assign is to the container.

Overlay Network

Enables communication between containers on different hosts, it is used to communicate in clustered environments.

Commands:

To create Custom Bridge Network

docker network create <network name>

To run the containers on same network

docker run -d --name <container name> --network <network name> <image name>

DockerFile Creation and Pushing images to DockerHub

Dockerfile — EasyShop Backend (Node.js + Express)

FROM node:18

WORKDIR /app

COPY package*.json ./

RUN npm install

COPY . .

EXPOSE 5000

CMD ["node", "index.js"]

To build Dockerfile and create image of it


docker build -t your-image-name:tag .

DockerHub

To push the images to DockerHub

docker login -u <username>

It will ask for your Docker Hub username and password (or personal access token).

To tag image with your Docker Hub username and pushing the image to DockerHub

docker tag local-image-name:tag dockerhub-username/repository-name:tag

Eg:

sudo docker tag easyshop-backend:latest poojabhavani08/easyshop-backend:latest

EasyShop — Base Demo App

EasyShop is our demo e-commerce app built with:

Frontend: React
Backend: Node.js/Express
Database: MongoDB

The Repository URL:

Clone this Repository

https://github.com/iemafzalhassan/easyshop--demo

You can use Docker to:
Containerize each part
Connect them using Docker networks
Persist data with Docker volumes
Practice cleanup, image builds, and container orchestration

Thanks all. Good luck out there!

Follow for more such amazing content :)

Happy Learning 😊

🖥️ Remote Equipment Request System – Build a Mini Admin Dashboard with HTML, CSS & JS

Pooja Bhavani — Tue, 08 Jul 2025 19:11:38 +0000

This is a submission for Frontend Challenge: Office Edition sponsored by Axero, Holistic Webdev: Office Space

What I Built

I created a Remote Equipment Request System using only HTML, CSS, and JavaScript.

This project is a web-based tool where employees can submit requests for work-related items (like laptops, chairs, monitors), and admins can review, approve, or reject those requests — all within a sleek browser interface.

It also helped me:

Practice DOM manipulation

Use eventListener effectively

Learn how to simulate data flow in a web app

Live Demo:

https://dev-pooja.netlify.app/

**GitHub Repo:
https://github.com/pooja-bhavani/Dev-Challenge

Journey

In remote-first workplaces, handling equipment logistics can become chaotic. This mini dashboard simulates how a simple internal tool could make life easier for both employees and IT/admins — all without a complex backend.

This project was a solo project

License

I grant Axero a worldwide, royalty-free license to display this project for promotional or marketing purposes, with credit. Full ownership remains with me.

Thanks to Axero and the DEV team for this cool challenge!

Automating Daily DevOps Job Search & Email Alerts

Pooja Bhavani — Sat, 05 Jul 2025 06:43:29 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge

Have you ever spent countless hours manually in checking LinkedIn or Indeed for the latest DevOps job postings? That’s exactly what inspired me to build an automated job search assistant using Runner H, powered by Google Workspace and intelligent prompt engineering.

How I Used Runner H

I used Runner H to build an autonomous AI agent that automates the process of finding and emailing the top DevOps job listings daily. Here's how I designed the workflow:

• Job Search via Web Scraping

The agent scrapes job portals like LinkedIn and Indeed using specific keywords related to DevOps roles (e.g., DevOps Engineer, SRE, Cloud Engineer).

• Filtering and Formatting

It filters out the top 5 most relevant jobs based on recency and relevance. These are then formatted into a short, readable summary including:

Job title

Company name

Location

Application link

• Automated Email Composition

Using the integrated Google Workspace, the agent generates an email containing these job summaries and sends it to the user’s inbox.

• No Manual Involvement

The entire flow runs automatically on demand — no coding, no switching tabs, and no daily searching required.

Let me walk you through how I created an agent that:

• Analyzes my resume
• Searches job portals daily
• Picks the top 5 most relevant jobs
• Emails me a beautifully formatted summary every morning

What Inspired This Project?

I was participating in the Runner H Prompt Engineering Challenge, which encourages creators to build helpful automation agents using prompt chaining and productivity tools.

My use case: Automate my DevOps job search workflow so I don’t miss fresh openings every morning.

Step-by-Step Breakdown

Step 1: Collecting User Input

The first step was to gather user details:

Full Name

Email Address

Preferred job roles and locations

Work preference (Remote/On-site/Hybrid)

Resume file (PDF)

Runner H prompts the user for this input at the beginning of the automation.

Step 2: Analyzing the Resume

Once the resume is uploaded, Runner H uses its language understanding to extract:


{
  "name": "Pooja Bhavani",
  "keywords": ["DevOps", "Docker", "AWS", "Kubernetes", "CI/CD", "Terraform"],
  "roles": ["DevOps Engineer", "Site Reliability Engineer"],
  "locations": ["Remote", "Bangalore"],
  "email": "poojabhavani@gmail.com"
}

This data becomes the foundation of the job search.

Step 3: Searching Job Platforms

Runner H searches jobs from:

LinkedIn Jobs

Indeed

It applies filters for:

Job postings within the last 24 hours

60%+ keyword match

Matching job title & location

The output looks like this:

[
  {
    "title": "DevOps Engineer",
    "company": "TechCorp",
    "location": "Remote",
    "link": "https://www.linkedin.com/jobs/view/123456"
  }
]

Step 4: Emailing the Results

Runner H formats the job results into an email and sends it at 9:00 AM IST daily.

✉️ Email Template:

Subject: Top 5 Job Matches for You Today


Hi {{user_name}},

Here are your top 5 DevOps job matches for {{today}}:

1. **{{job1_title}} – {{job1_company}}**
   📍 Location: {{job1_location}}  
   🔗 [Apply Now]({{job1_link}})

... and so on.

🌐 Platforms Searched: LinkedIn, Indeed

📅 Run Date: {{today}}

Good luck with your job search!

Why This Works

This automation:

Saves 30+ mins/day manually checking platforms

Surfaces relevant jobs before competitors

Lets me focus on preparation, not searching

Final Thoughts

I used Runner H as a no-code/low-code platform to stitch this all together using natural language.

It’s a great use case for:

Job seekers

Career coaches

Recruiting teams

If you’d like to try this for yourself, DM me or comment below 💬