DEV Community: Ritesh Kokam

Top 5 Upcoming Trends in Cloud Computing

Ritesh Kokam — Mon, 19 Oct 2026 14:07:22 +0000

Cloud computing continues to transform how businesses build applications, manage data, and deliver digital services. As we approach 2027, the focus is shifting from basic cloud adoption to smarter, more secure, and efficient cloud environments.

Artificial intelligence (AI), specialized computing infrastructure, hybrid cloud architectures, and sustainability are shaping the next phase of cloud innovation.

According to Gartner, public cloud spending in India is forecast to reach $17.5 billion in 2026, driven partly by demand for AI-ready infrastructure and application modernization.

Here are the top five upcoming trends in cloud computing to watch in 2027 and beyond.

1. Agentic AI and Autonomous Cloud Operations

Generative AI has changed how businesses create content, analyze information, and automate tasks. The next step is agentic AI, where AI systems can plan tasks, use tools, and execute multi-step workflows with varying levels of human supervision.

Cloud platforms provide the computing power and scalable infrastructure needed to support these intelligent systems.

Key applications include automated cloud monitoring, troubleshooting infrastructure issues, optimizing resource allocation, and assisting software development teams.

As these capabilities mature, businesses will increasingly use AI agents to improve operational efficiency and reduce repetitive manual work. However, access controls, human oversight, and security will remain essential when agents can modify systems or access sensitive information.

2. AI-Optimized Cloud Infrastructure

The growth of AI is increasing demand for specialized computing resources, including graphics processing units (GPUs), AI accelerators, high-speed networking, and scalable storage.

Cloud providers are expanding their AI infrastructure to support model training, inference, and other computationally intensive workloads.

Upcoming developments include more efficient AI processors, faster model inference, optimized data pipelines, and infrastructure designed for specific workloads.

For businesses, the objective will be to balance computing performance with cost and reliability. Selecting the right hardware, cloud services, and AI models can help organizations deliver faster results without unnecessary infrastructure spending.

AI-ready cloud infrastructure will become increasingly important as businesses move AI projects from experimentation into production.

3. Hybrid Cloud, Multicloud, and Data Sovereignty

Organizations are increasingly choosing where to run applications based on performance, cost, regulatory requirements, and security rather than relying on a single deployment model.

Hybrid cloud combines public cloud services with private infrastructure, while multicloud uses services from multiple providers. Both approaches offer flexibility when implemented with a clear strategy.

Data sovereignty is also gaining importance as businesses seek greater control over where their data is stored and processed.

These approaches can help organizations meet compliance requirements, maintain business continuity, and support applications that need local processing.

However, managing multiple environments can increase operational complexity. Businesses should establish consistent security policies, monitoring, identity management, and workload-placement strategies before expanding their cloud environments.

4. Cloud-Native Technologies and Platform Engineering

Cloud-native development continues to shape modern application architecture. Technologies such as containers, Kubernetes, microservices, and infrastructure as code help organizations build, deploy, and scale applications more efficiently.

According to the Cloud Native Computing Foundation's January 2026 survey, 82% of surveyed container users were running Kubernetes in production.

An important development alongside cloud-native adoption is platform engineering. Organizations are building internal developer platforms that allow teams to provision infrastructure, deploy applications, and access approved tools through standardized workflows.

This approach can improve developer productivity, reduce repetitive tasks, and embed security practices into software delivery.

As applications and AI workloads become more complex, cloud-native platforms will help businesses maintain consistency, scalability, and operational reliability.

5. Sustainable Cloud Computing and FinOps

As cloud usage expands, businesses are paying closer attention to infrastructure costs, energy consumption, and environmental impact.

FinOps, or cloud financial operations, helps organizations understand and optimize technology spending. AI-powered monitoring and automation can identify underutilized resources, forecast expenses, and recommend more efficient configurations.

The trend is becoming particularly important for AI workloads. The FinOps Foundation's 2026 survey found that 98% of respondents were managing AI-related spending.

Sustainability is another growing priority. The International Energy Agency reported in April 2026 that data center electricity consumption increased by 17% in 2025.

Businesses will increasingly focus on right-sizing infrastructure, reducing idle resources, improving utilization, and evaluating energy efficiency alongside performance and cost.

The goal is to achieve better business outcomes while making cloud environments more financially and environmentally sustainable.

Conclusion

The future of cloud computing will be shaped by intelligent automation, AI-optimized infrastructure, flexible deployment models, cloud-native platforms, and sustainable resource management.

As organizations plan for 2027 and beyond, success will depend on selecting technologies that address real business needs rather than adopting every new innovation.

Businesses that combine cloud modernization with strong security, cost optimization, and effective governance will be better positioned to innovate and remain competitive.

Cloud computing is evolving beyond infrastructure delivery into an intelligent, adaptable, and efficient foundation for digital transformation.

Top 5 Node.js Frameworks in 2026

Ritesh Kokam — Mon, 05 Oct 2026 14:46:35 +0000

Node.js has become a popular choice for developers looking to build scalable and high-performance applications. As the demand for Node.js continues to grow, choosing the right framework has become crucial for developers. Node.js frameworks provide essential tools that facilitate fast application development. These frameworks also promote code organization by providing structures and conventions for writing modular code that can be reused across different projects and teams.

Over the years, the Node.js ecosystem has continued to evolve, with developers now having more choices for building APIs, web applications, microservices, and serverless applications. Express.js remains the most widely used backend framework, while NestJS, Fastify, Hono, and AdonisJS have become strong choices for different development requirements. The State of JavaScript 2025 survey lists Express, NestJS, Fastify, Hono, and Adonis among the notable back-end frameworks, with newer frameworks such as Hono also receiving strong satisfaction ratings.

Is Node.js a Framework?

No, Node.js itself is not a framework. It’s a JavaScript runtime environment. Here’s the difference:

Node.js: Imagine it as a platform or engine. It allows you to run JavaScript code outside of a web browser, which is its typical environment. This opens doors for building server-side applications, tools, and more using JavaScript.
Framework: A framework is like a pre-built structure on top of Node.js. It provides a collection of libraries, tools, and pre-written code that streamline development. Popular Node.js frameworks like Express.js, NestJS, and Fastify leverage Node.js but offer additional features for building web applications and APIs efficiently.

Node.js itself continues to receive regular updates and new releases. In October 2026, Node.js 24 is an LTS release, while Node.js 26 is the Current release.

What are Node.js Frameworks?

Node.js frameworks are tools that help developers make web applications with Node.js. They provide a structured way to build apps and include pre-made code for common tasks like handling web requests, routing, validation, authentication, and managing application logic. Using these frameworks makes development faster and helps keep code organized.

Popular Node.js frameworks include Express.js, NestJS, Fastify, Hono, and AdonisJS. Other frameworks such as Koa.js and Hapi.js are also part of the Node.js ecosystem, but the frameworks listed below are stronger choices for a current 2026 overview based on usage, developer interest, and modern backend development needs.

Express.js

Express.js is a popular Node.js framework for building web applications in Node.js. It provides a robust set of features that help you build web apps and APIs quickly and easily, including:

Routing – Express provides an easy way to map URLs to functions within your application, allowing you to create complex routes for your users without having to worry about writing lots of boilerplate code.

Middleware – Middleware is used by Express to process requests and responses before they reach your route handlers, which allows you to add functionality like authentication, logging, security, and error handling.

Plugins – Express has a large ecosystem of third-party middleware and modules that extend its functionality with additional features such as database integrations, authentication, templating engines, and security tools.

Express has also been updated significantly since the earlier versions commonly used in older Node.js articles. Express 5 improved Promise support, so rejected Promises from route handlers and middleware can be passed to the error-handling middleware automatically. Express 5 also requires Node.js 18 or newer.

Express remains a strong choice for developers who want a simple, flexible, and mature framework with a large ecosystem. It continues to lead backend frameworks by usage in the State of JavaScript survey.

NestJS

NestJS is a server-side application framework that runs on Node.js. It’s built using TypeScript and is highly scalable and testable. The key advantage of using NestJS is its modular architecture, which enables developers to organize their code into reusable modules. This approach simplifies code maintenance and testing, and it promotes code reusability across different projects.

With the help of NestJS, APIs and Model View Controller (MVC) applications can be created. NestJS is also used to develop scalable and lightweight monoliths and microservices. NestJS provides many features and integrations for authentication, validation, database management, caching, logging, API documentation, and more.

Modular Architecture – NestJS allows developers to divide applications into modules, controllers, and providers, making large applications easier to maintain.

Dependency Injection – NestJS has a built-in dependency injection system that improves code organization and makes applications easier to test.

Express and Fastify Support – NestJS uses Express by default but can also work with Fastify through an adapter, allowing developers to choose the underlying HTTP platform.

NestJS continues to evolve with modern TypeScript and Node.js development. NestJS 12 introduced ESM-ready packages, Standard Schema support, an updated CLI, and native observability features, while existing CommonJS applications can continue to work.

NestJS is a good choice for application development when developers need a structured architecture for large applications, enterprise systems, APIs, and microservices.

Fastify

Fastify is a lightweight Node.js framework designed for building fast and scalable web applications and APIs. It focuses on low overhead, performance, extensibility, and a good developer experience. Fastify has become one of the most important alternatives to Express for developers who want a performance-focused backend framework.

Fastify provides several useful features, including:

Performance – Fastify is designed to keep framework overhead low, making it suitable for applications that need efficient request processing and high API performance.

Schema Validation – Fastify uses a schema-based approach and recommends JSON Schema for validating requests and serializing responses. This helps developers define the expected structure of incoming and outgoing data.

Plugins – Fastify provides a powerful plugin architecture that makes it easier to organize applications and reuse functionality across different parts of a project.

TypeScript Support – Fastify works well with TypeScript and provides type-provider options that can connect schemas with TypeScript types.

Fastify 5 was introduced with support for modern Node.js versions and currently remains the main supported major version. The framework is a strong choice for high-performance APIs, microservices, and backend services where validation and low overhead are important.

Hono

Hono is a lightweight Node.js framework that can be used for building web applications and APIs. Unlike traditional Node.js-only frameworks, Hono is designed around Web Standards, making it suitable for modern serverless and edge environments as well as Node.js applications.

Hono was built to be simple, fast, and flexible. It can run on Node.js, Cloudflare Workers, Deno, Bun, AWS Lambda, Fastly Compute, Vercel, and other compatible environments. Hono uses standard web APIs such as Request, Response, URL, Headers, and Fetch, while also providing a Node.js adapter.

Some of the important features of Hono include:

Lightweight – Hono has a small and simple API, making it suitable for building lightweight services and APIs.

Web Standards – Hono uses Web Standards APIs, which makes it easier to move applications between different supported JavaScript runtimes.

Middleware – Hono provides middleware for common tasks such as authentication, logging, CORS, caching, compression, and security.

Multi-Runtime Support – Developers can use Hono across Node.js, serverless platforms, and edge runtimes without having to completely change the application structure.

Hono has become one of the notable newer backend frameworks in the JavaScript ecosystem. In the State of JavaScript 2025 survey, Hono was among the highest-rated back-end frameworks for satisfaction, making it an interesting choice for modern application development.

Hono is a good choice for lightweight APIs, serverless applications, edge computing, and projects that need to run across multiple JavaScript runtimes.

AdonisJS

AdonisJS is a TypeScript-first Node.js framework designed for developers who want a structured and feature-rich approach to backend development. It provides more functionality out of the box compared with lightweight frameworks such as Express.

AdonisJS follows a batteries-included approach. This means developers can use official tools and packages for common backend requirements instead of assembling every part of an application from different third-party libraries.

Some of its important features include:

TypeScript Support – AdonisJS is built around TypeScript and provides a strongly typed development experience for modern Node.js applications.

MVC Architecture – AdonisJS provides a structured architecture for building web applications and APIs, which makes it easier to organize and maintain larger projects.

Authentication and Validation – AdonisJS provides official solutions and integrations for common backend requirements such as authentication, validation, and authorization.

Database Management – AdonisJS includes Lucid, its SQL ORM, which provides database access, relationships, migrations, and other database features.

AdonisJS has continued to develop in 2026 with the release of AdonisJS 7. The latest major version introduced improvements across the framework, including stronger end-to-end type safety, updated official packages, new starter kits, and other developer-experience improvements.

AdonisJS is a good choice for developers who want a complete and structured backend framework with many common features already available.

Conclusion

In conclusion, selecting the right Node.js framework is essential for efficient and scalable application development. Express.js, NestJS, Fastify, Hono, and AdonisJS each offer unique features and advantages that cater to different development needs.

Whether you prioritize simplicity, performance, modular architecture, serverless support, TypeScript, or built-in backend features, there is a Node.js framework that fits your project requirements.

Express.js is a strong choice when you need flexibility and a mature ecosystem. NestJS is well suited for large applications that require a structured and modular architecture. Fastify is a good option when performance and schema-based validation are important. Hono is especially useful for lightweight APIs and applications running across serverless and edge environments. AdonisJS is a strong choice for developers who prefer a more complete, batteries-included TypeScript framework.

As the Node.js ecosystem continues to evolve in 2026, these frameworks provide developers with different approaches to building modern web applications, APIs, and backend services. Choose the framework based on your project requirements, team experience, performance needs, application architecture, and deployment environment.

API Design 101: From Basics to Best Practices

Ritesh Kokam — Mon, 21 Sep 2026 14:44:42 +0000

In this deep dive, we’ll go through the API design, starting from the basics and advancing towards the best practices that define exceptional APIs.

As a developer, you’re likely familiar with many of these concepts, but I’ll provide a detailed explanation to deepen your understanding.

API Design: An E-commerce Example

Let’s consider an API for an e-commerce platform like Shopify, which, if you’re not familiar with is a well-known e-commerce platform that allows businesses to set up online stores.

In API design, we’re concerned with defining the inputs (like product details for a new product) and outputs (like the information returned when someone queries a product) of an API.

This means that we focus on the interface rather than the low-level implementation

API Design and CRUD

So, the focus is mainly on defining how the CRUD operations are exposed to the user or system interacting with your e-commerce API.

CRUD Stands for Create, Read, Update, Delete. These are the basic operations of any data-driven application.

For example, to add a new product (Create), you would make a POST request to /api/products where the product details are sent in the request body.

To retrieve products (Read), you need to fetch data with a GET request from /products.

For updating product information (Update), we use PUT or PATCH requests to /products/:id, where id is the id of a product we need to update.

Removing is similar to updating; we make a DELETE request to /products/:id where id is the product we need to remove (Delete).

Communication Protocol and Data Transport Mechanism

Another part is to decide on the Communication Protocol that will be used, like HTTP, WebSockets, etc, and the Data Transport Mechanism: JSON, XML, or Protocol Buffers.

This is the case with RESTful APIs, but we also have GraphQL or gRPC paradigms

API Paradigms

APIs come in different paradigms, each with its own set of protocols and standards.

REST (Representational State Transfer)

Pros: Stateless: Each request from a client to a server must contain all the information needed to understand and complete the request. Uses standard HTTP methods (GET, POST, PUT, DELETE). Easily consumable by different clients (browsers, mobile apps).

Cons: This can lead to over-fetching or under-fetching of data- because More endpoints may be required to access specific data.

Features: Supports pagination, filtering (limit, offset), and sorting. Uses JSON for data exchange.

GraphQL

Pros: Allows clients to request exactly what they need, avoiding over-fetching and under-fetching. Strongly typed schema-based queries.

Cons: Complex queries can impact server performance. All requests are sent as POST requests.

Features: Typically responds with HTTP 200 status code, even in case of errors, with error details in the response body.

gRPC (Google Remote Procedure Call)

Pros: Built on HTTP/2, it provides advanced features like multiplexing and server push. Uses Protocol Buffers, a language-neutral, platform-neutral, extensible way of serializing structured data. Efficient in terms of bandwidth and resources, especially suitable for microservices.

Cons: Less human-readable compared to JSON. Requires HTTP/2 support.

Features: Supports data streaming and bi-directional communication. Ideal for server-to-server communication.

Relationships in API Design

In an e-commerce setting, you might have relationships like the user to orders, orders to products, etc.

Designing endpoints to reflect these relationships is important. For example, in this scenario GET /users/{userId}/orders should fetch orders for a specific user.

Queries, Limit, and Idempotence of GET Requests

Common queries also include limit and offset for pagination or startDate and endDate for filtering products within a certain date range. This allows users to retrieve specific sets of data without overwhelming the system or the user with too much information at once.

A well-designed GET request is idempotent, meaning calling it multiple times doesn’t change the result.

GET requests should never mutate data. They are meant only for retrieval.

Backward Compatibility and Versioning

When modifying endpoints, it’s important to maintain backward compatibility. This means ensuring that changes don’t break existing clients.

Versioning: Introducing versions (like /v2/products) is a common practice to handle significant changes.

In the case of GraphQL, adding new fields (v2 fields) without removing old ones helps in evolving the API without breaking existing clients.

Rate Limitats and CORS

Another best practice is to set rate limitations. This is used to control the number of requests a user can make in a certain timeframe. This is crucial for maintaining the reliability and availability of your API. It also prevents the API from DDoS attacks.

Common practice is to also set CORS settings Cross-Origin Resource Sharing (CORS) settings are important for web security. They control which domains can access your API, preventing unwanted cross-site interactions.

Taming the Docker Zoo with Docker Compose

Ritesh Kokam — Mon, 07 Sep 2026 14:47:33 +0000

Ever felt like a zookeeper wrangling a pride of lions, a gaggle of geese, and a school of clownfish... all at once? That's kind of what managing multiple Docker containers can feel like. But fear not, weary developer! Docker Compose is here to be your whip-cracking (metaphorical, of course) assistant.

From Chaos to Orchestration

Docker is fantastic for running isolated applications, but when your project grows to include multiple containers, such as a database, a web server, and a cache layer, things can get messy. Manually starting, stopping, connecting, and managing dependencies between these containers can quickly become frustrating.

This is where Docker Compose swoops in, like a knight in shining YAML armor. It allows you to define and manage your entire multi-container application in a single, easy-to-read YAML file. This file specifies:

The containers (services) you need: Web server, database, cache, and more.
Configuration for each service: Image to use, ports to expose, environment variables, volumes, and more.
Dependencies between services: Control the startup order between services and, when needed, wait for a dependency to become healthy before starting a dependent service.

Docker Compose Commands

Docker Compose offers powerful commands to manage your application's lifecycle:

docker compose up: Starts all defined services, bringing your application to life.
docker compose down: Stops and removes the containers and networks created for the application.
docker compose build: Builds custom Docker images within your project.
docker compose logs: Views the combined logs from your running services.

Docker Compose is run with the docker compose command. The older standalone docker-compose command is a legacy installation intended mainly for backward compatibility.

Beyond the Basics

Docker Compose offers additional features to streamline development:

Environment-specific configurations: Use different configurations for development, testing, and production with ease.
Volume mounting: Share data between your containers and your development environment for seamless testing.
Scaling services: Need more capacity for a service? Configure Compose to run multiple instances of a service when appropriate.

Docker Compose: Your Development Ally

Docker Compose streamlines the development process by:

Reducing boilerplate code: Define your application configuration in a single YAML file.
Enhancing development reproducibility: Achieve consistent development environments across machines.
Facilitating collaboration: Share your YAML file for easy setup by other developers.
Simplifying deployment: Use the same YAML configuration as a foundation for deployment, reducing transition risks.

Getting Started with Docker Compose

Ready to unleash the power of Docker Compose? Here's a quick guide:

Install Docker: Download and install Docker Desktop from the official website. Docker Desktop includes Docker Compose, Docker Engine, and the Docker CLI. On Linux, you can install the Docker Compose plugin separately when Docker Engine and the Docker CLI are already installed.
Create a YAML file: Use a plain text editor to create a file named compose.yaml in your project directory. compose.yaml is the preferred default Compose filename.
Define services: Specify your application's services within the YAML file.
Configure services: Define details like image, ports, environment variables, and volumes for each service.
Run your application: Open a terminal in your project directory and run docker compose up.

Docker Compose uses the current Compose Specification, so you do not need to add a top-level version: "3.8" declaration. The version field is obsolete in modern Compose and is retained only for backward compatibility with older Compose files.

Example: Building a Simple Web App

Imagine a web application with a Python Flask backend and a MySQL database. Traditionally, you'd manage these components separately. Here's how Docker Compose simplifies this:

services:
  web:
    build: .  # Build the Docker image for the web app from the current directory
    ports:
      - "5000:5000"  # Map container port 5000 to host port 5000
    environment:
      DATABASE_URL: mysql://db:3306/mydatabase  # Use the db service name to connect to MySQL
    volumes:
      - .:/app  # Mount current directory as /app within the container

  db:
    image: mysql:9.7  # Use the official MySQL 9.7 image
    environment:
      MYSQL_ROOT_PASSWORD: root  # Set the root password for MySQL
    volumes:
      - mysql_data:/var/lib/mysql  # Persist database data in a named volume

volumes:
  mysql_data:  # Define a named volume to persist database data

This YAML file defines:

Services: Defines two services:
- web: Builds its image from the current directory, exposes port 5000, sets an environment variable for the database connection, and mounts the current directory as /app.
- db: Uses the official MySQL image (mysql:9.7), sets the root password for MySQL, and uses a named volume (mysql_data) to persist database data.
Volumes: Defines a named volume called mysql_data for persistent storage of the database information.

The web service can connect to the database using the service name db. Compose provides service-to-service networking for containers in the application, so applications can use the service name instead of a container IP address.

When an application needs to wait until the database is actually ready to accept connections, you can add a healthcheck to the database and use depends_on with condition: service_healthy. By default, Compose waits for a dependency to be running, not necessarily ready to accept requests.

Embrace Docker Compose!

By leveraging Docker Compose, you can tame your Docker zoo, manage complex applications with ease, and streamline your development workflow. So, ditch the chaos and embrace the orchestration!

Resources

Docker basics for beginners

Creating Docker Images

Creating a Docker Image for Beginners: A Complete Guide

Ritesh Kokam — Mon, 17 Aug 2026 14:06:40 +0000

After learning the Docker basics, it is time to create our images. Creating our own custom Docker image allows us to have more control over application configurations, dependencies, security, and more. And it is easy and fun. Get ready for it!

Why Create Custom Docker Images?
Doing the Process Steps Manually
Creating Our Docker Image
Making Our Docker Image Public
Final Thoughts
Resources

Why Create Custom Docker Images?

Custom Docker images give us control over application configurations and dependencies, improving security and performance. We can create a custom Docker image tailored to our own needs, with the dependencies we want, and the code we want.

For example, we want everybody in our dev team to use Ubuntu 24.04 with Apache and the code in one GitHub repo. We could create a custom Docker image, upload it, and tell everybody in the dev team to work using that image.

No more dependencies problem, no more "I don't know how to install X" and, especially, no more "But it works on my computer".

We just need to create one image packaged with all we need, that executes every step we want.

Doing the process steps manually

One tip before creating our own custom Docker image is to do the process manually: We get a clean Linux system (a Virtual Machine created with Vagrant is an easy way as you can use the image and discard it later) and we run the commands we want.

Using a process of trial and error, we install and configure everything we want until it is done. We will repeat these steps on our Docker image.

For this, of course, you need to have Docker installed (and, if not, here's how to Install Docker).

Let's start then!

We want to run a Flask web application inside an Ubuntu OS. The steps we want to do are:

Install Ubuntu
Install Python and its required tools
Create a Python virtual environment
Install Flask dependency
Copy our Python code
Run the Flask web application

So, let's start!

First, let's download a Docker image, then create a container using that image, and run the bash terminal:

docker run -it ubuntu:24.04 bash

Now we are in the container's terminal as root. Let's install our dependencies:

apt update

apt install -y python3 python3-pip python3-venv

Ubuntu 24.04 uses an externally managed Python environment, so instead of installing Flask directly into the system Python, we create a virtual environment:

python3 -m venv /opt/venv

Activate it:

. /opt/venv/bin/activate

Now install Flask:

pip install flask

Now we have everything we need to run our code.

You can create a Flask app, search for one on GitHub that you want to use, or just use an application I have created for this tutorial.

Copy the code and paste it inside /opt/app.py.

import os
from flask import Flask

app = Flask(__name__)

@app.route("/")
def main():
    return "Welcome!"

@app.route("/How are you")
def how_are_you():
    return "I'm fine, how about you?"

@app.route("/about")
def about():
    return "I'm just a small Flask app :)"

@app.route("/info")
def info():
    return "I have been created just to pass Pau's subject."

if __name__ == "__main__":
    app.run()

Everything is set, time to run the server!

/opt/venv/bin/flask --app /opt/app.py run --host=0.0.0.0 --port=5000

Now the Flask server is listening on port 5000 inside the container.

Creating our Docker image

We have our server running perfectly. Now, we want to reproduce the same steps in a Docker image so we can distribute it.

First, close everything and check the container isn't running:

docker ps

Now, let's create a folder for us to work in. Inside, create a Dockerfile (a text document that contains all the commands we want to run) where we will create a script to do all the steps we did before:

mkdir app_flask
cd app_flask

vim Dockerfile

Our Dockerfile will contain:

FROM ubuntu:24.04

RUN apt-get update && \
    apt-get install -y python3 python3-venv && \
    rm -rf /var/lib/apt/lists/*

WORKDIR /opt

COPY app.py /opt/app.py

RUN python3 -m venv /opt/venv && \
    /opt/venv/bin/pip install --no-cache-dir flask

EXPOSE 5000

CMD ["/opt/venv/bin/flask", "--app", "/opt/app.py", "run", "--host=0.0.0.0", "--port=5000"]

The important difference from our original Dockerfile is that we use a Python virtual environment. This is appropriate for current Ubuntu releases, where Python packages should not be installed directly into the system-managed Python environment.

We also use the exec form of CMD. Docker supports both shell and exec forms, with the exec form providing clearer process and signal handling. EXPOSE documents that the application listens on port 5000; it does not publish the port to the host by itself.

Now we can run Docker build to run the script and create a Docker image. But before, as we see in the COPY line, we need to have our script in the same folder. Copy it or just download it with wget:

wget https://raw.githubusercontent.com/david1707/flask-app/main/app.py

Now build the image:

docker build . -t david1707/app-flask-caminas:1.0

Remember to change the image's name, following the convention of <YOUR_NAME>/<IMAGE_NAME>.

I have also added the 1.0 tag so that we can identify this version of the image. If no tag is specified, Docker uses latest by default, but explicit version tags are useful when you want to distinguish different image versions.

After the build completes, you have your custom Docker image.

Now let's run it:

docker run -d \
  --name app-flask-caminas \
  -p 5000:5000 \
  david1707/app-flask-caminas:1.0

Now we can visit:

http://localhost:5000

The Flask application is running inside our Docker container.

Making public our Docker image

Now we can distribute the Docker image and everybody will have the same image, with the same dependencies.

We can publish it in a Docker repository, for example, in Docker Hub. Very much like GitHub, Docker Hub allows us to store and share container images.

You have to register in Docker Hub first, then log in:

docker login

If your image isn't already tagged with your Docker Hub username, tag it:

docker tag david1707/app-flask-caminas:1.0 <YOUR_DOCKER_USERNAME>/app-flask-caminas:1.0

Then push it to Docker Hub:

docker push <YOUR_DOCKER_USERNAME>/app-flask-caminas:1.0

Docker's current documentation uses this same workflow: authenticate, tag the image with the Docker Hub namespace and repository, and then push the tagged image.

Now anyone with access to the repository can use your image with:

docker run -p 5000:5000 <YOUR_DOCKER_USERNAME>/app-flask-caminas:1.0

This will download the image if it isn't on the computer and run it.

Now we can visit:

http://localhost:5000

Final thoughts

Creating our own Docker images is pretty easy. We just need the basics of using the terminal, then we can replicate all the steps in a Dockerfile to create our images, even distributing them via Docker Hub.

The benefits of using our own custom Docker images are:

Customization: Creating and using your own Docker images allows for tailored configurations, ensuring that the image contains specific dependencies, settings, and optimizations that align with the requirements of your applications.
Security Compliance: By building and managing your own Docker images, we have direct control over the inclusion and configuration of security measures and dependencies.
Reduced Image Size: Customizing Docker images allows for the elimination of unnecessary components, resulting in smaller image sizes. Smaller images can lead to faster deployment times and more efficient resource utilization.
Flexibility and Specialized Tooling: Building our own Docker images provides the flexibility to incorporate specialized tooling or unique requirements specific to your organization's workflows. This customization lets teams create and deploy applications with the exact environment they need.

Resources

Original post

Docker basics for beginners

Build, tag, and publish an image

Docker Basics for Beginners: A Complete Guide

Ritesh Kokam — Mon, 03 Aug 2026 14:31:35 +0000

If you've searched for Docker, you already know it's described as a software platform that uses OS level virtualization to produce self sufficient containers. That's accurate, but it's not exactly beginner friendly language. Let's break it down in plain terms, with commands you can actually run today.

What is Docker?
Docker vs. Virtual Machines
What's New in Docker Right Now
Installing Docker
Basic Docker Commands
Real World Example: Running Jenkins
Data Persistence with Volumes
FAQ
Final Thoughts
Resources

What is Docker?

Docker lets you package an application and everything it needs to run (code, runtime, libraries, system tools) into a single unit called a container.

Think of it in two parts:

Image. A read only template or blueprint used to create one or more containers. It's essentially a recipe.

Container. A running instance of an image, isolated from other containers, with its own filesystem and environment.

If you've used Oracle VM VirtualBox or Vagrant before, Docker will feel familiar. You pick an image, spin up an instance, and work inside it. The difference is how Docker does this under the hood, and that's what makes it faster and lighter than a traditional VM (more on that below).

Here's a minimal Dockerfile, the instructions used to build an image:

FROM ubuntu:24.04
RUN apt-get update
RUN apt-get install -y curl nginx

This tells Docker to start from Ubuntu 24.04, update the package index, then install curl and nginx. Build a container from this image and you get a ready to use Ubuntu environment, already updated and pre loaded with curl and nginx.

Because every developer on a team builds from the same image, everyone gets the same OS, the same package versions, and the same behavior. The "but it works on my machine" problem effectively disappears.

Docker vs. Virtual Machines

If a Docker container behaves like a mini virtual machine, why not just use VMs?

The key difference is that Docker containers share the host machine's kernel instead of virtualizing an entire guest operating system. That makes containers dramatically lighter and faster to start, often in a second or two, compared to the minutes a full VM boot can take.

This matters most when you're shipping code. Say you're building a Node.js app on a specific Node version. You can:

Create a Docker image starting from a base OS
Install the exact Node.js version and dependencies your app needs
Share that image with your team or deploy it to any Docker compatible server

Nobody has to manually match package versions or babysit a deployment checklist. The server's underlying OS, installed packages, or programming language don't matter. Docker runs the image as is. Upload the image, run it, and you're deployed.

What's New in Docker Right Now

If you last touched Docker a while back, a few things have changed:

Docker Engine 29.x is the current stable line, having succeeded the 28.x series. It ships with security fixes, an updated runc and RootlessKit, and changes to how concurrent image pulls and pushes are throttled by default.

Docker Compose is on the v5 line (currently v5.3.0), with ongoing improvements to docker buildx bake, build resource limits (--resource), and source policy validation for build image authenticity.

docker sandbox has been removed in favor of docker sbx. Update any scripts or docs that still reference the old experimental sandbox plugin.

Docker Desktop's Logs (Beta) view now surfaces directly from docker logs, compose logs, compose attach, and compose up, giving you a unified log panel across running containers.

Ubuntu 26.04 LTS ("Resolute Raccoon") is now supported alongside 24.04 LTS and 22.04 LTS in Docker's official apt repository.

Docker has also continued shipping regular CVE fixes across the engine, Desktop, and the Model Runner AI component. If you're running Docker in production, keeping current with point releases matters more than ever. Check the Docker Engine release notes before upgrading in any CI or production pipeline.

Installing Docker

You can install Docker Desktop (GUI) or Docker Engine (CLI only). Both are actively maintained, so pick based on your workflow rather than any old "real developers use the terminal" bias.

Full, OS specific instructions live at:

For Debian based distros (Ubuntu 22.04, 24.04, or 26.04):

Remove any old versions first:

sudo apt-get purge docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras
sudo rm -rf /var/lib/docker
sudo rm -rf /var/lib/containerd

Install Docker via the official convenience script:

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh ./get-docker.sh

Verify the install:

sudo docker version

Run a test container:

sudo docker run docker/whalesay cowsay boo

If that prints an ASCII whale saying "boo," Docker is working.

Running Docker without `sudo` (do this the safe way)

By default, every Docker command needs sudo because the Docker daemon socket is owned by root. The usual fix is adding your user to the docker group:

sudo usermod -aG docker $USER
newgrp docker

Log out and back in (or reboot) for the group change to take effect, then test with docker run hello-world. No sudo needed.

A note on security: you may see older tutorials suggest running sudo chmod 666 /var/run/docker.sock to skip the sudo prompt. Avoid this. It makes the Docker socket world writable, which is basically equivalent to giving any local user root access to the host, since Docker containers can mount the host filesystem. Adding your user to the docker group gets you the same convenience without that exposure. If you need tighter isolation altogether, look into rootless Docker (dockerd-rootless-setuptool.sh install), which runs the daemon itself without root privileges.

Basic Docker Commands

A cheat sheet of the commands you'll use daily:

Task	Command
List downloaded images	`docker images`
Run a container from an image	`docker run <IMAGE_NAME>`
Run a specific version/tag	`docker run <IMAGE_NAME>:<VERSION>`
Run in the background (detached)	`docker run -d <IMAGE_NAME>`
Reattach to a running container	`docker attach <ID>`
Pull an image without running it	`docker pull <IMAGE_NAME>`
Run a command inside a running container	`docker exec <CONTAINER> <COMMAND>`
Open a shell inside a container	`docker run -it <IMAGE_NAME> bash`
List running containers	`docker ps`
List all containers (including stopped)	`docker ps -a`
Map a container port to the host	`docker run -p <HOST_PORT>:<CONTAINER_PORT> <IMAGE_NAME>`
Inspect an image or container (JSON)	`docker inspect <NAME_OR_ID>`
View a container's logs	`docker logs <NAME_OR_ID>`
View an image's layer history	`docker history <IMAGE_NAME>`
Stop a running container	`docker stop <NAME_OR_ID>`
Remove a container	`docker rm <NAME_OR_ID>`
Remove an unused image	`docker rmi <IMAGE_NAME>`
Build an image from a Dockerfile	`docker build . -t <NAME>`
Set an environment variable	`docker run -e <VAR>=<VALUE> <IMAGE_NAME>`
Adjust CPU/memory of a running container	`docker container update --cpus 2 --memory 512m <NAME>`

A couple of examples in context:

# Inspect the OS release info inside an Ubuntu container
docker run ubuntu cat /etc/*release*

# Run a container that sleeps for 15 seconds, then exits
docker run ubuntu sleep 15

# Pass an environment variable to an app image
docker run -e APP_COLOR=blue simple-webapp-color

To connect one container to another (say, a web app that needs Redis), the modern approach is a user defined network rather than the legacy --link flag:

docker network create app-net
docker run -d --name redis --network app-net redis
docker run -d -p 5000:80 --name voting-app --network app-net voting-app

Containers on the same network can reach each other by container name. No --link (deprecated) required.

Real World Example: Running Jenkins in Docker

Jenkins is a widely used CI/CD automation tool, and it's a great first "real" container to run.

docker run jenkins/jenkins        # download and start Jenkins
docker ps                         # get the container ID
docker inspect <CONTAINER_ID>     # get the container's internal IP

To reach Jenkins from your host machine's browser, rather than only inside a VM, map the container port to a host port:

docker run -p 8080:8080 jenkins/jenkins

Now open http://localhost:8080 in your browser. If you're running Docker inside a Linux VM on a Windows or Mac host, the chain looks like this: host machine, then Linux VM, then Docker container.

Port mapping is what lets a request from your host browser reach a lightweight container running two layers down.

Data Persistence with Volumes

Stop the Jenkins container, come back the next day, restart it, and your setup screens, jobs, and configuration are gone. What happened?

Containers are ephemeral by default. Jenkins stores its data at /var/jenkins_home inside the container, but running the image again creates a brand new container with a fresh filesystem. Your old data isn't there.

Option 1: Bind mount a host folder

mkdir my_jenkins_data
docker run -p 8080:8080 -v /home/<USERNAME>/my_jenkins_data:/var/jenkins_home jenkins/jenkins

This links a folder on your host (my_jenkins_data) to the container's /var/jenkins_home. Anything Jenkins writes there persists on your host disk, so restarting the container, or even recreating it, picks up right where you left off.

Option 2: Docker managed volumes

Instead of tracking a host path yourself, let Docker manage storage under /var/lib/docker/volumes/:

docker volume create test_volume
docker run -v test_volume:/var/lib/mysql mysql

Or using the more explicit --mount syntax:

docker run --mount type=bind,source=/data/mysql,target=/var/lib/mysql mysql

Named volumes are generally preferred for production because Docker handles backup, migration, and driver plugins (think cloud storage backends) for you.

Frequently Asked Questions

Is Docker still relevant, or has something replaced it?
Yes. Docker Engine and Docker Compose continue to receive active development and regular security updates, and Docker images remain the de facto standard supported by essentially every cloud provider and CI/CD platform.

Do I need Docker Desktop, or is Docker Engine enough?
Docker Engine (CLI plus daemon) is sufficient for servers, CI runners, and Linux native development. Docker Desktop adds a GUI, a Kubernetes toggle, and extra tooling like Model Runner for local AI models. That's mainly useful on macOS and Windows, or if you just prefer a visual interface.

What replaced docker sandbox?
docker sandbox was an experimental plugin that has since been removed. Use docker sbx instead.

Is it safe to run Docker without sudo?
Yes, as long as you add your user to the docker group rather than loosening permissions on the daemon socket directly (see the security note above). Membership in the docker group is functionally equivalent to root access on the host, so only add trusted users.

What's the difference between -v and --mount?
Both attach storage to a container. -v (or --volume) is shorter and more common. --mount is more explicit and verbose, and it's generally recommended for Swarm services or when you need fine grained control over mount options.

Final Thoughts

Docker earns its popularity for a handful of concrete reasons.

It gives you real isolation, running applications insulated from the host system and from each other. It's efficient, since sharing the host kernel means far less overhead than full VMs. It's portable, because an image runs the same way on any Docker compatible host. It's scalable, letting you spin up more containers to handle more load and scale back down just as easily. It keeps things consistent, moving the same image from a developer's laptop through CI to production and eliminating environment drift. It plugs into a huge ecosystem of tools, Docker Hub, Docker Compose, Kubernetes, and a massive library of official images. And ultimately it simplifies deployment: you ship an image, not a checklist of dependencies to install by hand.

Resources

10 Best Websites for Web Design Inspiration in 2026

Ritesh Kokam — Mon, 20 Jul 2026 14:11:06 +0000

Finding inspiration is easy.

Finding good inspiration is hard.

With thousands of design galleries available today, it's easy to get lost scrolling through endless screenshots without learning anything useful. The best inspiration websites don't just showcase beautiful interfaces, they help you discover design patterns, user flows, layouts, and ideas that you can adapt to your own projects.

Whether you're designing a SaaS product, startup landing page, portfolio, agency website, or eCommerce store, studying successful websites can significantly improve your design decisions.

To save you time, I've curated 10 of the best web design inspiration websites in 2026. These are trusted by UI/UX designers, developers, founders, and agencies worldwide to stay updated with modern design trends.

1. SaaSpo

Best for: SaaS products, AI startups, and marketing websites

If you're designing SaaS products, SaaSpo is one of the most valuable inspiration resources available today.

Unlike general website galleries, SaaSpo focuses entirely on SaaS and startup websites, making every example relevant. Instead of endlessly browsing unrelated designs, you can quickly explore websites based on page type, design style, industry, or technology stack.

Whether you're building a pricing page, feature page, AI product, or product launch website, SaaSpo helps you discover layouts that are both beautiful and conversion-focused.

Why Designers Love It

Huge collection of SaaS websites
AI product inspiration
Browse by Hero, Pricing, Features, Login pages
Filters for Webflow, Framer, Next.js, Astro, and more
Regularly updated with modern designs

👉 Best if you: Build SaaS products or startup landing pages regularly.

2. Refero

Best for: Product designers and UX researchers

Refero is much more than a design gallery.

It's one of the largest collections of real-world UI patterns and user flows from successful digital products.

Instead of simply showing attractive websites, Refero lets you study how leading companies design onboarding flows, dashboards, authentication pages, settings, pricing pages, search experiences, and much more.

If you're solving a UX problem, chances are Refero already has dozens of examples you can learn from.

Why Designers Love It

Thousands of real product screens
Organized by user flows
Excellent UX research resource
Great for dashboards and SaaS apps
Frequently updated

👉 Best if you: Design digital products, dashboards, or web applications.

3. Mobbin

Best for: UI patterns and mobile app inspiration

Mobbin has become one of the most popular resources for UI designers, and for good reason.

It features thousands of curated interfaces from leading web and mobile applications, making it easy to explore how top products solve common UX challenges.

Need inspiration for a checkout flow? Login screen? Profile page? Empty state?

Mobbin organizes everything into categories, saving countless hours of research.

It's especially useful when designing products that require intuitive user experiences.

Why Designers Love It

Huge collection of web and mobile interfaces
Complete user flows
Organized by screen type
High-quality UI patterns
Great search functionality

👉 Best if you: Build products rather than marketing websites.

4. Lapa Ninja

Best for: Landing pages

Lapa Ninja has been one of the internet's favorite landing page galleries for years.

Its carefully curated collection includes startups, AI companies, agencies, fintech businesses, healthcare platforms, educational websites, and much more.

The best part?

Every design is clean, modern, and conversion-focused.

You can quickly browse by industry, page type, or style to find inspiration that matches your next project.

Why Designers Love It

Thousands of landing pages
Industry-specific inspiration
Easy-to-use navigation
Excellent visual quality
Updated frequently

👉 Best if you: Need inspiration for marketing or product landing pages.

5. Land-book

Best for: Everyday website inspiration

If you simply want a reliable source of modern website designs, Land-book remains one of the best options.

Its collection spans startups, portfolios, agencies, blogs, AI products, and corporate websites.

Unlike some galleries that prioritize quantity over quality, Land-book focuses on showcasing polished, well-crafted websites that are actually useful for designers.

It's one of those websites you'll keep coming back to whenever you're starting a new project.

Why Designers Love It

Beautiful curated collection
Modern design trends
Excellent typography inspiration
Wide variety of industries
Beginner-friendly

👉 Best if you: Want an all-purpose web design inspiration gallery.

6. Awwwards

Best for: Award-winning websites and cutting-edge web experiences

If you're looking for websites that push the boundaries of creativity, Awwwards should be at the top of your bookmark list.

The platform showcases websites recognized for excellence in design, creativity, usability, and innovation. While some projects are highly experimental, they're an excellent source of inspiration for animations, storytelling, interactions, and immersive experiences.

It's also a great place to discover new design agencies and freelancers producing world-class work.

Why Designers Love It

Award-winning website collection
Incredible animations and interactions
Inspiring creative layouts
Excellent typography and branding
Discover top design studios

👉 Best if you: Want to explore the latest trends in creative web design.

7. Godly

Best for: Modern UI and startup websites

Godly has quickly become a favorite among designers who want fresh, contemporary website inspiration.

The gallery features everything from SaaS products and AI tools to portfolios, agencies, and eCommerce stores. Its clean interface and well-curated collection make it easy to discover modern layouts without feeling overwhelmed.

You'll often spot emerging design trends here before they become mainstream.

Why Designers Love It

Modern startup websites
AI and SaaS inspiration
Clean browsing experience
Updated regularly
Excellent typography examples

👉 Best if you: Want fresh inspiration that reflects current design trends.

8. SiteInspire

Best for: High-quality curated websites

SiteInspire has been a trusted resource for designers for years, and it continues to be one of the most reliable inspiration galleries.

Rather than showcasing thousands of random websites, SiteInspire carefully curates each submission, ensuring consistently high-quality designs.

You can browse websites by style, subject, platform, and content type, making it easy to find examples relevant to your project.

Why Designers Love It

Carefully curated collection
Powerful search filters
Wide range of industries
Clean and distraction-free interface
Timeless design inspiration

👉 Best if you: Need polished inspiration for professional or client projects.

9. Landingfolio

Best for: Conversion-focused landing pages

Beautiful websites are great, but websites that convert visitors into customers are even better.

Landingfolio focuses on high-performing landing pages from startups and established companies across industries like AI, SaaS, finance, healthcare, and education.

Instead of browsing purely for aesthetics, you can study how successful businesses structure headlines, present features, build trust with testimonials, and encourage users to take action.

It's an excellent resource for both designers and marketers.

Why Designers Love It

High-converting landing pages
Organized by industry
Great CTA and pricing examples
Strong messaging inspiration
Perfect for SaaS products

👉 Best if you: Design websites with a focus on conversions and marketing.

10. One Page Love

Best for: Single-page websites and portfolios

As its name suggests, One Page Love specializes in beautifully designed one-page websites.

Whether you're creating a personal portfolio, product launch page, event website, or agency landing page, you'll find plenty of inspiration here.

The curated collection highlights websites that communicate effectively without requiring multiple pages, a valuable approach for startups and small businesses.

Why Designers Love It

Beautiful one-page websites
Startup and portfolio inspiration
Clean navigation
Excellent storytelling examples
Beginner-friendly

👉 Best if you: Need inspiration for compact, high-impact websites.

Final Thoughts

Great web design isn't about following every trend, rather it's about solving problems through thoughtful, user-focused experiences.

The websites featured in this list offer far more than visual inspiration. They showcase proven layouts, effective UI patterns, and modern design approaches that can help you create better websites faster.

Whether you're a beginner learning the fundamentals or an experienced designer looking for fresh ideas, bookmarking these resources will give you a solid starting point for your next project.

Which web design inspiration website do you use the most? Let me know in the comments, I'd love to discover more great resources!

Understanding the Top 7 Frontend Security Attacks

Ritesh Kokam — Tue, 30 Jun 2026 14:00:47 +0000

In the digital age, securing web applications is of paramount importance. Every day, over 2,200 cyber-attacks occur as a result of poorly designed web applications. Here, we delve into the top seven common frontend security attacks and how to prevent them.

1. Cross-Site Scripting (XSS)

Cross-Site Scripting, or XSS, is a prevalent attack where malicious client-side scripts are injected into trusted websites, which are then executed in the user’s browser. These scripts can access and steal sensitive information stored within the browser, such as cookies, session tokens, or other sensitive information that the user might have entered into the website.

Prevention: To prevent XSS attacks, it’s crucial to validate and sanitize forms and input fields that allow users to insert data. This means checking that the data is of the correct type, length, format, and range. Additionally, implementing a Content Security Policy (CSP) can restrict resources and scripts that are loaded. Modern JavaScript frameworks like Angular, Vue, and React have built-in preventive mechanisms against XSS attacks.

2. SQL Injections

SQL Injections manipulate database queries to gain unauthorized database access. Attackers can execute SQL Queries from your frontend, leading to destructive actions like dropping your database.

Prevention: To prevent SQL injections, it’s important to validate and sanitize frontend input fields and backend payloads. This means checking that the data is of the correct type, length, format, and range. Using parameterized queries or prepared statements can also help prevent SQL injections. Additionally, tools like Burp Scanner, sqlmap, jSQL Injection, and Invicti can be used to detect potential SQL attacks.

3. Cross-Site Request Forgery (CSRF)

Cross-Site Request Forgery, or CSRF, forces victims to execute unwanted actions in an app they’re logged into. An attacker could trick users with a disguised link that quietly transfers funds from their account using their stored credentials.

Prevention: To prevent CSRF attacks, it’s important to implement anti-CSRF tokens in your application. These tokens ensure that the requests made to your server are legitimate and originated from your website. Additionally, using the “SameSite” attribute for cookies can help prevent CSRF attacks.

4. Clickjacking

Clickjacking uses transparent overlays on a trusted page to trick users into clicking on something different than they perceive. For example, an attacker could overlay a transfer funds button or a cat video’s play button.

Prevention: To prevent clickjacking attacks, it’s important to implement the X-Frame-Options HTTP response header. This tells the browser whether you want to allow your site to be framed or not. Additionally, using framebusting scripts can help prevent clickjacking attacks.

5. Dependency Exploitation

Front-end apps rely on many third-party libraries and components. If these have vulnerabilities, they undermine the whole app.

Prevention: To prevent dependency exploitation, it’s important to regularly update your dependencies and use tools like npm audit or Snyk to identify known vulnerabilities. Additionally, using a package manager that supports lockfiles can ensure that you’re using the correct versions of your dependencies.

6. Security Misconfiguration Attacks

Security misconfiguration attacks exploit default configurations, incomplete or ad hoc configurations, open cloud storage, misconfigured HTTP headers, and verbose error messages containing sensitive information.

Prevention: To prevent security misconfiguration attacks, it’s important to regularly review and update your configurations. Ensure error messages do not reveal sensitive information. Additionally, using a security configuration review tool can help identify potential security misconfigurations.

7. Man-in-the-Middle Attack

In a Man-in-the-Middle attack, the attacker secretly relays and possibly alters the communication between two parties.

Prevention: To prevent Man-in-the-Middle attacks, it’s important to use HTTPS for all your pages. Implementing HTTP Strict Transport Security (HSTS) can ensure the browser only connects to your server via HTTPS. Additionally, using a VPN can help prevent Man-in-the-Middle attacks.

Conclusion

In conclusion, understanding these common frontend security attacks and their prevention methods is crucial for building secure web applications. Stay vigilant and keep your applications safe!

Let’s Stay Connected! 🤝

If you found this post helpful, follow me for more tech insights, updates, and discussions:

✨ Thank you for reading! Feel free to share your thoughts or reach out—I’d love to hear from you. 🚀

PWA in 2026: Why Progressive Web Apps Still Matter

Ritesh Kokam — Mon, 15 Jun 2026 14:11:42 +0000

The web has come a long way from being a platform for simple websites. Today, modern web applications can deliver fast, reliable, and engaging experiences that closely resemble traditional mobile and desktop apps. At the heart of this evolution are Progressive Web Apps (PWAs).

A Progressive Web App combines the reach of the web with many of the capabilities users expect from installed applications. Users can access a PWA through a browser, install it on their device, receive updates automatically, and in many cases continue using it even when network connectivity is limited.

While new technologies and trends continue to emerge, PWAs remain one of the most practical ways to build and distribute modern applications across multiple platforms.

What Is a Progressive Web App?

A Progressive Web App is a web application that uses modern browser technologies to provide an app-like experience. Unlike traditional websites, PWAs can be installed on a user's device, launched from a home screen or desktop, and offer features such as offline support, push notifications, and access to selected device capabilities.

The concept is built around progressive enhancement. The application works for everyone through the browser while providing additional functionality on devices and browsers that support advanced features.

This approach allows developers to create a single application that serves users across smartphones, tablets, laptops, and desktop computers without maintaining multiple platform-specific codebases.

What Can PWAs Do in 2026?

Modern browsers have significantly expanded the capabilities available to web applications.

Today's PWAs can:

Capture photos, videos, and audio using device cameras and microphones
Access location services for navigation and location-based experiences
Send push notifications to keep users informed and engaged
Support secure authentication methods such as biometrics and passkeys
Open, edit, and save files directly from the browser
Integrate with native sharing features on supported devices
Process payments through modern payment systems
Work offline using intelligent caching and synchronization
Access selected device hardware and sensors where supported
Deliver rich media experiences, including audio and video playback

The result is an experience that feels increasingly similar to traditional applications while retaining the accessibility and flexibility of the web.

Why Businesses Are Choosing PWAs

One of the biggest advantages of PWAs is efficiency.

Instead of building separate applications for Android, iOS, desktop platforms, and the web, organizations can often serve the majority of their users through a single codebase. This reduces development effort, simplifies maintenance, and accelerates product delivery.

PWAs also eliminate many of the barriers associated with app distribution. Users can access the application instantly through a URL and decide later whether they want to install it. This creates a smoother onboarding experience and can improve user acquisition.

Another important benefit is deployment speed. Updates can be released immediately without requiring users to download new versions manually. This enables teams to fix issues, improve performance, and ship features faster.

For startups and growing businesses, these advantages often translate into lower costs and faster time-to-market.

Benefits for Users

PWAs offer several advantages that directly improve the user experience.

Fast and Responsive

Modern caching techniques help applications load quickly and remain responsive, even on slower networks.

Reliable Access

Offline support allows users to continue interacting with content and services when internet connectivity becomes unreliable.

Easy Installation

Users can install a PWA directly from their browser without navigating app stores or downloading large installation packages.

Automatic Updates

Because updates are delivered through the web, users always have access to the latest version of the application.

Cross-Platform Compatibility

The same application can work across a wide range of devices and operating systems, providing a consistent experience wherever users access it.

PWAs in the AI Era

Artificial intelligence is becoming a standard feature in modern software, but it does not change the fundamental value of PWAs.

Many applications now include intelligent search, recommendations, automation, content generation, or conversational interfaces. These capabilities can be delivered effectively through a Progressive Web App while maintaining the advantages of web-based deployment.

The rapid pace of AI innovation has actually highlighted one of the strengths of PWAs: instant updates. Teams can continuously improve features and deploy enhancements without requiring users to install new versions manually.

At the same time, the success of any application still depends on core fundamentals such as performance, usability, accessibility, security, and reliability. PWAs provide a strong foundation for delivering these qualities regardless of whether AI features are included.

Are PWAs the Future?

The debate about whether PWAs can replace native applications has largely evolved into a more practical discussion: choosing the right tool for the right problem.

Native applications still make sense for certain use cases that require deep operating system integration or highly specialized hardware access. However, for many business applications, SaaS platforms, e-commerce stores, customer portals, content platforms, and productivity tools, PWAs offer an excellent balance between capability, reach, and development efficiency.

Rather than being viewed as an alternative to native apps, PWAs have established themselves as a mature application platform in their own right.

Conclusion

Progressive Web Apps have moved well beyond their early adoption phase. They now provide a reliable and cost-effective way to build modern applications that work across devices while delivering many of the experiences users expect from native software.

With features such as offline support, installability, push notifications, secure authentication, and access to modern device capabilities, PWAs continue to bridge the gap between websites and traditional applications.

In 2026, they remain one of the smartest choices for organizations looking to build fast, accessible, and scalable digital experiences without the complexity of maintaining multiple platform-specific applications.

PWA in 2026: Why Progressive Web Apps Still Matter

Ritesh Kokam — Mon, 15 Jun 2026 14:11:42 +0000

While new technologies and trends continue to emerge, PWAs remain one of the most practical ways to build and distribute modern applications across multiple platforms.

What Is a Progressive Web App?

This approach allows developers to create a single application that serves users across smartphones, tablets, laptops, and desktop computers without maintaining multiple platform-specific codebases.

What Can PWAs Do in 2026?

Modern browsers have significantly expanded the capabilities available to web applications.

Today's PWAs can:

Capture photos, videos, and audio using device cameras and microphones
Access location services for navigation and location-based experiences
Send push notifications to keep users informed and engaged
Support secure authentication methods such as biometrics and passkeys
Open, edit, and save files directly from the browser
Integrate with native sharing features on supported devices
Process payments through modern payment systems
Work offline using intelligent caching and synchronization
Access selected device hardware and sensors where supported
Deliver rich media experiences, including audio and video playback

The result is an experience that feels increasingly similar to traditional applications while retaining the accessibility and flexibility of the web.

Why Businesses Are Choosing PWAs

One of the biggest advantages of PWAs is efficiency.

For startups and growing businesses, these advantages often translate into lower costs and faster time-to-market.

Benefits for Users

PWAs offer several advantages that directly improve the user experience.

Fast and Responsive

Modern caching techniques help applications load quickly and remain responsive, even on slower networks.

Reliable Access

Offline support allows users to continue interacting with content and services when internet connectivity becomes unreliable.

Easy Installation

Users can install a PWA directly from their browser without navigating app stores or downloading large installation packages.

Automatic Updates

Because updates are delivered through the web, users always have access to the latest version of the application.

Cross-Platform Compatibility

The same application can work across a wide range of devices and operating systems, providing a consistent experience wherever users access it.

PWAs in the AI Era

Artificial intelligence is becoming a standard feature in modern software, but it does not change the fundamental value of PWAs.

Are PWAs the Future?

The debate about whether PWAs can replace native applications has largely evolved into a more practical discussion: choosing the right tool for the right problem.

Rather than being viewed as an alternative to native apps, PWAs have established themselves as a mature application platform in their own right.

Conclusion

5 Web Design Trends of 2026

Ritesh Kokam — Mon, 01 Jun 2026 14:05:23 +0000

Web design is a dynamic and evolving field that constantly adapts to new technologies, user preferences, and best practices. As we move ahead, the digital landscape has shifted from purely aesthetic choices to deeply immersive, interactive, and high-performance user experiences. Drawing from the latest design shifts observed across major product systems and the Figma ecosystem, the way we experience the web is undergoing a massive transformation. In this article, I'll share with you 5 web design trends that are completely shaping the digital landscape and how you can use them to create stunning, future-proof websites for your clients. Let's get started!

1. 3D & Immersive Elements

Web interfaces have completely broken free from flat, rigid boundaries. Websites are increasingly blending hyper-realistic, fully interactive 3D models directly into structural layout layers to create rich, spatial experiences. Rather than treating 3D elements as background decorations, modern design relies on them as core components of user discovery.

This approach completely reinvents how users evaluate physical or abstract objects online. By leveraging optimized assets, you can deliver these heavy-impact interactive features smoothly on mobile viewports and desktop setups alike.

It elevates online product storytelling by allowing users to physically rotate, disassemble, or manipulate items in real time.
It replaces static imagery with active exploration, dramatically increasing the time a user spends engaged on the landing screen.
It builds an instant perception of high-end quality and tech-forward innovation for a client's brand identity.

2. Ultra-Massive Bold Typography

Typography has stepped past its traditional role of simple legibility to become the primary artwork on the web page. Hero layouts are heavily ditching traditional photo blocks in favor of ultra-massive headlines, custom display typefaces, and fluid letterforms that expand, stretch, or shift weight based on user navigation.

Using variable typography rules allows the text to behave like a living element. Letters can change slant, adapt to container sizes, or even split apart to allow interaction models to seamlessly fit around key conversion text.

It grabs immediate consumer focus inside the critical first three seconds of a page load.
It reduces reliance on heavy imagery, allowing websites to stay performance-focused and visually striking at the same time.
It maximizes native search index crawl performance, as the primary messaging is rendered entirely through accessible code rather than flattened graphics.

3. Kinetic Motion Design & Animation

Static web design feels increasingly obsolete. Current layouts embrace integrated motion design—ranging from delicate micro-interactions to deep, scroll-driven multi-axis parallax animations that react physically to a user's cursor speed and movement direction.

The magic here lies in contextual feedback. Elements don't just flash into view; they glide, scale, or transform based on gravity variables, giving the interface a tactile, incredibly responsive sense of space.

It guides user navigation by using physical movement to highlight essential interactive points, like checkouts and feature highlights.
It transforms mundane data consumption into a pleasant narrative journey that reacts directly to the user's input.
It eliminates jarring, sudden visual jumps by substituting them with elegant structural transformations that keep the user grounded.

4. Gamified Interface Frameworks

To capture and retain shrinking user attention spans, websites are widely borrowing UX mechanics directly from video games. This incorporates active reward metrics, visible challenge markers, progress indicators, and playful interactions that turn typical browsing tasks into engaging digital quests.

Gamification works wonderfully when applied to onboarding funnels, data input steps, or user dashboards. By framing interaction steps as satisfying milestones, user completion rates climb drastically.

It dramatically boosts user interaction and retention rates by appealing to natural behavioral triggers.
It simplifies complex onboarding setups, turning multi-stage question forms into short, enjoyable challenges.
It fosters deep brand loyalty by transforming transactional interactions into personalized user milestones.

5. Soft-Skeuomorphic Neumorphism

Neumorphism has officially matured into a clean, sophisticated design tool. By artfully layering soft, opposing inner and outer shadows with subtle background gradients, this aesthetic crafts beautifully physical, tactile buttons and cards that look extruded from or recessed into the digital canvas.

Unlike the flat design trends of previous years, neumorphic elements present an incredibly smooth, approachable finish. It brings back a digital texture that makes buttons feel truly clickable and inputs feel authentically tactile.

It yields an incredibly soft, unified aesthetic that feels comfortable during extended viewing sessions.
It reintroduces physical depth to flat layouts, restoring a natural sense of interaction priority.
It creates a minimal, ultra-modern luxury feel that is exceptionally well-suited for fine art portfolios, modern dashboards, and fintech products.

Conclusion

The overarching trend in modern web design is crystal clear: Interfaces are becoming live environments. The rigid, static layouts of the past have stepped aside for adaptive, multi-dimensional, and highly engaging digital spaces. By combining immersive 3D, expressive kinetic typography, smooth physics-driven motion, gamified pathways, and tactile soft UI depth, you can build digital experiences that look premium and convert brilliantly.

What do you think of these web design trends? Which style are you most excited to implement in your upcoming client workflows? Let me know in the comments below!

If you enjoyed this breakdown and found it helpful, feel free to share it with your design team, and don't forget to subscribe to the newsletter for more cutting-edge design concepts. Thank you for reading and happy designing!

Best GitHub Alternatives for Developers in 2026

Ritesh Kokam — Mon, 18 May 2026 14:00:00 +0000

GitHub continues to dominate the developer ecosystem in 2026, but it is no longer the only serious platform for source code management and collaboration. Modern development teams now expect far more than just Git hosting. They want integrated CI/CD pipelines, project management, package registries, security scanning, self-hosting options, AI-assisted workflows, and better control over infrastructure and privacy.

That shift has pushed many developers and organizations to explore GitHub alternatives that better match their workflows, budgets, and deployment preferences.

Whether you are:

looking for a self-hosted GitHub alternative,
building an enterprise DevOps pipeline,
managing open-source projects,
or simply searching for a cheaper and more flexible platform,

there are several excellent options available in 2026.

In this guide, we compare the best GitHub alternatives for developers in 2026, including their features, advantages, disadvantages, pricing considerations, and ideal use cases.

Why Developers Are Looking Beyond GitHub

GitHub remains an industry leader, but developers often look for alternatives because of:

Rising costs for advanced enterprise features
Limited customization in cloud-hosted environments
Preference for self-hosted infrastructure
Better DevOps integration
Stronger privacy and data control
Lightweight alternatives for smaller teams
Open-source governance preferences

The good news is that today’s alternatives are more mature than ever.

1. GitLab

GitLab remains one of the strongest GitHub competitors in 2026. It is widely recognized as a complete DevOps platform that combines source control, CI/CD, issue tracking, project management, security scanning, and deployment tools into a single application.

GitLab is especially popular among enterprises and teams that want an all-in-one DevOps solution without relying on multiple third-party integrations.

Key Features

Git repository hosting
Built-in CI/CD pipelines
Security and vulnerability scanning
Self-hosted and cloud-hosted options
Agile planning and issue tracking
Container registry support
Kubernetes integration

Pros

Complete end-to-end DevOps platform
Excellent CI/CD tooling out of the box
Strong enterprise and self-hosting capabilities
Large open-source community
Flexible deployment options

Cons

Self-hosted setup can require significant resources
Advanced enterprise features can become expensive
Steeper learning curve for smaller teams

Best For

Enterprises
DevOps-focused teams
Organizations requiring self-hosting
Large engineering teams

2. Bitbucket

Bitbucket is Atlassian’s Git repository hosting platform and remains a popular alternative for teams already using Jira, Trello, or Confluence.

Its strongest advantage is seamless integration with the Atlassian ecosystem, making it ideal for structured software development workflows.

Key Features

Git-based source control
Pull requests and code review
Jira and Trello integration
Built-in CI/CD with Bitbucket Pipelines
Branch permissions and deployment controls
Cloud and enterprise offerings

Pros

Excellent Jira integration
Strong team collaboration features
Reliable cloud infrastructure
Good free tier for small teams
Easy onboarding for Agile teams

Cons

Less customizable than self-hosted alternatives
Advanced security features require paid plans
Best experience depends heavily on Atlassian products

Best For

Agile software teams
Jira-centric organizations
Small to mid-sized companies
Teams already using Atlassian tools

3. Gitea

Gitea has become one of the most popular lightweight self-hosted GitHub alternatives in 2026.

Built with simplicity and performance in mind, Gitea is ideal for developers who want full control over their repositories without the operational complexity of larger platforms.

Key Features

Lightweight Git hosting
Self-hosted deployment
Pull requests and code review
Built-in package registry
Gitea Actions for CI/CD
Team and repository management

Pros

Extremely lightweight and fast
Easy to deploy on minimal infrastructure
Open-source and community-driven
Supports GitHub Actions-compatible workflows
Great for personal and small-team hosting

Cons

Fewer enterprise-grade features
Smaller ecosystem compared to GitLab
Requires self-hosted infrastructure management

Best For

Developers who prefer self-hosting
Small engineering teams
Personal projects
Open-source communities

4. Forgejo

Forgejo is a newer but rapidly growing Git hosting platform focused on community governance, decentralization, and lightweight self-hosting.

It originated as a community-driven fork and has gained attention among developers who value transparency and open governance models.

Key Features

Lightweight self-hosted Git service
Repository management
CI/CD through Forgejo Actions
Open governance model
GitHub-compatible workflows
Community-focused development

Pros

Fully open-source and community-led
Lightweight and efficient
Easy deployment
Strong privacy and ownership control
Active developer community

Cons

Smaller ecosystem than GitHub or GitLab
Limited enterprise tooling
Still growing adoption compared to major platforms

Best For

Privacy-focused developers
Open-source communities
Self-hosting enthusiasts
Small development teams

5. Azure DevOps

Azure DevOps is Microsoft’s integrated DevOps suite that combines Git repositories, CI/CD pipelines, Agile boards, package management, and testing tools.

For organizations already invested in the Microsoft ecosystem, Azure DevOps remains one of the most powerful GitHub alternatives available.

Key Features

Azure Repos for Git hosting
Azure Pipelines for CI/CD
Azure Boards for project tracking
Enterprise security and compliance
Hybrid cloud and on-premises support
Deep Microsoft ecosystem integration

Pros

Excellent enterprise tooling
Powerful CI/CD pipelines
Strong compliance and security features
Works well with Azure cloud services
Suitable for large organizations

Cons

Interface can feel complex
Overkill for smaller teams
Best experience tied to Microsoft ecosystem

Best For

Enterprise organizations
Microsoft-centric companies
Large DevOps teams
Hybrid cloud environments

GitHub Alternatives Comparison Table

Platform	Hosting Type	CI/CD	Self-Hosted	Best For
GitLab	Cloud + Self-hosted	Excellent	Yes	Full DevOps workflows
Bitbucket	Cloud	Good	Limited	Atlassian users
Gitea	Self-hosted	Good	Yes	Lightweight Git hosting
Forgejo	Self-hosted	Good	Yes	Open-source communities
Azure DevOps	Cloud + On-premises	Excellent	Yes	Enterprise teams

How to Choose the Right GitHub Alternative

Choosing the best GitHub alternative depends on your team’s priorities.

Choose GitLab if:

You want an all-in-one DevOps platform
You need advanced CI/CD
Your organization prefers self-hosting

Choose Bitbucket if:

Your team already uses Jira or Atlassian products
You want easy cloud-based collaboration
You manage Agile development workflows

Choose Gitea or Forgejo if:

You prefer lightweight self-hosted infrastructure
Privacy and ownership matter most
You want a simpler Git hosting experience

Choose Azure DevOps if:

Your company uses Microsoft technologies
You need enterprise-grade DevOps tooling
You manage large-scale engineering teams

Final Thoughts

The Git hosting landscape in 2026 is more competitive and developer-friendly than ever before.

GitHub may still lead the market, but platforms like GitLab, Bitbucket, Gitea, Forgejo, and Azure DevOps each offer compelling advantages depending on your workflow, infrastructure requirements, and team size.

The best GitHub alternative is ultimately the one that aligns with your development process, collaboration style, security needs, and long-term scalability goals.

If you are planning to migrate away from GitHub, start by evaluating:

Hosting requirements
CI/CD needs
Team size
Security requirements
Budget
Integration ecosystem

The right platform can significantly improve developer productivity and streamline your software delivery pipeline.

Happy coding! 🚀

DEV Community: Ritesh Kokam

Top 5 Upcoming Trends in Cloud Computing

1. Agentic AI and Autonomous Cloud Operations

2. AI-Optimized Cloud Infrastructure

3. Hybrid Cloud, Multicloud, and Data Sovereignty

4. Cloud-Native Technologies and Platform Engineering

5. Sustainable Cloud Computing and FinOps

Conclusion

Top 5 Node.js Frameworks in 2026

Is Node.js a Framework?

What are Node.js Frameworks?

Express.js

NestJS

Fastify

Hono

AdonisJS

Conclusion

API Design 101: From Basics to Best Practices

API Design: An E-commerce Example

API Design and CRUD

Communication Protocol and Data Transport Mechanism

API Paradigms

REST (Representational State Transfer)

GraphQL

gRPC (Google Remote Procedure Call)

Relationships in API Design

Queries, Limit, and Idempotence of GET Requests

Backward Compatibility and Versioning

Rate Limitats and CORS

Taming the Docker Zoo with Docker Compose

From Chaos to Orchestration

Docker Compose Commands

Beyond the Basics

Docker Compose: Your Development Ally

Getting Started with Docker Compose

Example: Building a Simple Web App

Embrace Docker Compose!

Resources

Creating a Docker Image for Beginners: A Complete Guide

Table of Contents

Why Create Custom Docker Images?

Doing the process steps manually

Creating our Docker image

Making public our Docker image

Final thoughts

Resources

Docker Basics for Beginners: A Complete Guide

Table of Contents

What is Docker?

Docker vs. Virtual Machines

What's New in Docker Right Now

Installing Docker

Running Docker without sudo (do this the safe way)

Basic Docker Commands

Real World Example: Running Jenkins in Docker

Data Persistence with Volumes

Option 1: Bind mount a host folder

Option 2: Docker managed volumes

Frequently Asked Questions

Final Thoughts

Resources

10 Best Websites for Web Design Inspiration in 2026

1. SaaSpo

Why Designers Love It

2. Refero

Why Designers Love It

3. Mobbin

Why Designers Love It

4. Lapa Ninja

Why Designers Love It

5. Land-book

Why Designers Love It

6. Awwwards

Why Designers Love It

7. Godly

Why Designers Love It

8. SiteInspire

Why Designers Love It

9. Landingfolio

Why Designers Love It

Running Docker without `sudo` (do this the safe way)