Applying GCP, AI & Modern Web to Build a Summarized News Experience

Amit Verma — Sat, 01 Aug 2026 19:22:09 +0000

While preparing for the Google Cloud Architect certification, I wanted to deepen my understanding by building something practical using the GCP services I was learning. That led me to start a news summarization application, this is something I've been developing and refining in my personal time to apply cloud and AI/ML concepts in action.

My goal was clear, while working on app to create a fast, minimal, and clean reading experience that offers summarized news instead of going through the large articles, giving readers the key updates of the articles without scrolling endlessly. It is a mobile-first, web-based app designed for easy to use. Readers can swipe through articles just like they would do while browsing reels or short videos. This makes web based app experience intuitive and similar to mobile natives app.

Architecture of application

At the same time, I chose Next.js to build the app, which made it easier to deploy on Cloud Run and helped to meet the SEO requirements effectively. As we know, strong SEO is essential for any web-based application, and Next.js with its built-in server side rendering and dynamic routing perfectly supports these needs.

Over time, the technical scope expanded, allowing me to explore and apply a wide range of GCP Services. Here’s a quick breakdown of what I have used so far:

Firebase : for app authentication, Firestore for NoSQL, Hosting, and Functions for backend logic
Cloud Run : to deploy the Next.js app.
Cloud Functions & Cloud Scheduler : to fetch and summarize news at regular intervals
Cloud Storage and Cloudinary : to manage article media.
Secret Manager & IAM : to secure resources access.
Artifact Registry : to store artifact after build.
Cloud Build : to build the project
Analytics and Logs : for monitoring
Next.js (using TypeScript) : chosen for its server-side rendering capabilities and SEO friendliness.
TailwindCSS : to create a smooth and responsive user experience
Other : Swiper.js, etc
Using a vector database to enable similarity-based retrieval
Integrating with a retrieval-augmented generation (RAG) to give fast response to user-queries.
Working on fine-tuning the T5-small model using the CNN/DailyMail dataset test data for summarize the articles. This will take lot of time and I am going to post learning from this fine-tuning as well.
And many more...

You can explore the app here(Mobile-first) : https://www.inbits.co
(Feedback is always appreciated!)

This entire experience has been a way for me to stay hands-on, apply what I’ve learned, and keep up with real-world use cases in cloud, full-stack development, and machine learning.

Difference between var, let and const in JavaScript

Amit Verma — Sat, 10 Jun 2023 23:55:50 +0000

In JavaScript, the keywords var, let, and const are used to declare variables, but they have some key differences in terms of scope, hoisting, and mutability. Here's a brief explanation of the differences between these three variable declarations:

var: The var keyword has been used in JavaScript for a long time. Variables declared with var are function-scoped, meaning they are accessible within the function in which they are declared. If a variable is declared with var outside of any function, it becomes globally scoped and can be accessed throughout the entire script. One important thing to note is that variables declared with var are hoisted, which means they are moved to the top of their scope during the compilation phase.

Example:

function exampleFunction() {
    var x = 10;
    if (true) {
        var y = 20;
        console.log(x); //Output 10
    }
    console.log(y); //output 20
}
exampleFunction();

let: Introduced in ECMAScript 6 (ES6), the let keyword allows the declaration of block-scoped variables. Block scope means the variable is only accessible within the nearest pair of curly braces {} where it is declared. Unlike var, let variables are not hoisted to the top of their scope. They are only accessible after their declaration statement. Additionally, let variables can be reassigned new values, but their scope remains within the block where they are defined.

Example:

function exampleFunction() {
    let x = 10;
    if (true) {
        let y = 20;
        console.log(x); // 10
    }
    console.log(y); // ReferenceError: y is not defined
}
exampleFunction();

const: Also introduced in ES6, the const keyword is used to declare constants. Constants are block-scoped and cannot be reassigned after declaration. This means that once a value is assigned to a const variable, it cannot be changed. Like let, const variables are also not hoisted and are only accessible after their declaration statement.

Example:

function exampleFunction() {
    const x = 10;
    if (true) {
        const y = 20;
        console.log(x); // 10
    }
    console.log(y); // ReferenceError: y is not defined
}
exampleFunction();

In summary, var is function-scoped and hoisted, let is block-scoped and not hoisted, and const is block-scoped and immutable. It is recommended to use let and const over var due to the more predictable scoping behavior they provide. Additionally, using const for variables that should not be reassigned helps to write more robust and error-free code.

It's important to note that the scope and behavior of these keywords may change depending on whether they are used in the global scope, function scope, or inside other constructs like loops or conditionals. Understanding variable scoping and the differences between var, let, and const is crucial for writing clean and reliable JavaScript code.

Thanks for reading.
Happy coding

DEV Community: Amit Verma

Applying GCP, AI & Modern Web to Build a Summarized News Experience

Architecture of application

Difference between var, let and const in JavaScript