The Technology Behind Modern Websites: Our Stack

A modern website is no longer just a page of HTML and CSS.

Depending on the project, a website may involve a frontend framework, databases, APIs, payment gateways, authentication, content management, cloud infrastructure, plus analytics and, increasingly, AI-assisted development. A small business website does not need the same architecture as a SaaS platform. An industrial catalogue does not need the same stack as an e-commerce application, and a payment-based application needs a very different backend from a static portfolio.

At NKV DEV WORKS, we pick technology according to the problem, not because a particular framework is popular. That is why our development stack includes Astro, React, MERN, Cloudflare, Razorpay, shadcn/ui, Starwind UI, Kokonut UI, TypeScript, Node.js, Git, plus AI development tools such as OpenCode.

---

Our Development Philosophy

Before choosing a technology, we ask a simple question:

What does this project actually need?

A content-heavy business website puts performance and SEO at the top of the list. An application usually cares more about interactivity and state management, while an e-commerce platform adds payments, orders, inventory and security on top of both. For a B2B catalogue, discoverability, product organisation, enquiry generation can matter more than online checkout.

There is no single best tech stack. There is only the right stack for the project.

Related reading: see our 8-page guide to the different types of websites for how we match project type to architecture.

---

Astro: Our Choice for Fast, Content-Driven Websites

Astro is one of the technologies we particularly like for modern business websites.

It is designed for content-driven sites such as marketing sites, blogs, portfolios, documentation, landing pages, e-commerce experiences. Its architecture emphasises server-rendered HTML and keeps unnecessary JavaScript out of the browser. (Astro’s official docs explain the design goals in detail.) Content for that kind of site usually comes from a git-backed CMS rather than a database, which is why this blog runs on Pages CMS.

The most useful idea inside Astro is Islands Architecture. Instead of turning an entire page into one large JavaScript application, most of the page stays lightweight HTML and the interactive parts load only where a visitor actually needs them.

On a business website, the static HTML covers:

• Navigation
• Hero section
• Services
• About section
• Product descriptions
• Blog content
• Footer

JavaScript is left for the parts that respond to a visitor:

• Mobile menu
• Product filters
• Image carousel
• Search
• Interactive pricing calculator
• Contact form

That split matters when performance and SEO are important. We don’t want to send a large JavaScript application to someone who simply wants to read a page, and on a content site that is almost everyone who arrives.

---

React: When the Website Needs Application-Level Interactivity

React is a different kind of tool, and it earns its place when the interface itself behaves like an application rather than a document. The examples are familiar: dashboards, admin panels, SaaS products, complex forms, real-time interfaces, data-heavy views.

Using React does not mean abandoning Astro. Astro supports multiple UI frameworks and lets us add interactive components only where they are actually needed, so a project rarely has to be 100 per cent Astro or 100 per cent React. We can design the architecture around the requirements instead of around a preference.

---

MERN: A Full-Stack JavaScript Approach

For application-heavy projects, the MERN stack remains an important option. The acronym covers MongoDB, Express, React and Node.js. React handles the presentation layer, Express on top of Node.js forms the application layer, and MongoDB provides the database.

A typical architecture runs in one direction: React frontend → Express / Node.js API → MongoDB.

That shape suits applications with user accounts, authentication, APIs, dashboards, CRUD operations, complex application logic, real-time functionality. MERN is not automatically the best choice for every website, though. A simple company website gains nothing from a full MERN architecture except complexity, while a genuine web application gets a very capable stack with one language across the whole codebase.

---

Cloudflare: More Than Just DNS

Cloudflare is another major part of modern web infrastructure. Most people know it only as a DNS and CDN provider, and its developer platform goes much further than that.

Cloudflare Workers provides a serverless environment for building and deploying applications on Cloudflare’s global network. It supports multiple languages and frameworks, including JavaScript, TypeScript, React, Astro.

That reach makes Cloudflare interesting for projects that want global delivery, serverless APIs, edge computing, static hosting, database connectivity, application backends, CDN, security. For some projects the architecture becomes Astro → Cloudflare Pages / Workers → Cloudflare D1, which gives us a modern deployment model without maintaining a traditional VPS for every project. We use this on our own site and for fast, globally distributed client builds.

---

Cloudflare D1: SQL Database at the Edge

When an application requires a database, Cloudflare D1 can be an interesting option. D1 is Cloudflare’s managed serverless SQL database, based on SQLite semantics, and Workers and Pages projects can query it directly. (Cloudflare’s D1 documentation is the reference we follow.)

A business application built this way has three layers: Astro or React on the frontend → Cloudflare Workers for the API → Cloudflare D1 for the database.

That arrangement works well for POS systems, inventory systems, business dashboards, customer management, internal tools, booking systems, product catalogues. In each case the technology follows the requirements of the application rather than a one-size-fits-all architecture.

---

Razorpay: Connecting Websites to Real Payments

A website becomes significantly more interesting when it needs to accept money.

For Indian businesses, payment integration is an important part of e-commerce and custom web applications. Razorpay provides the gateway integrations we use, including web-based Standard Checkout and API-based flows. (Razorpay’s integration docs cover both the hosted checkout and the API flow.)

A working payment architecture is more than a “Pay Now” button: customer → website → create order → payment gateway → payment → server-side verification or webhook → order confirmation. Razorpay’s documentation describes creating an order server-side and using webhooks for server-side confirmation in standard web integrations, which is why a payment system deserves treating as an engineering problem rather than a frontend feature.

---

shadcn/ui: Components You Actually Own

Traditional component libraries work by installing a package and importing components from it. shadcn/ui takes a different approach: it describes itself as a collection of accessible components and a code distribution platform, and components are added to your project as source code that developers can modify and extend directly. (shadcn/ui’s docs describe the add-to-codebase model.)

That difference matters when you are building a custom interface. With a package library the loop is install, use the component, then fight the library’s styles whenever the design departs from its defaults. With shadcn/ui the component source lands in your project, so you modify it, extend it and own it.

It currently supports setups including Astro, Vite, React, Next.js. For teams that want a consistent design system without being locked into a rigid component API, this approach is particularly attractive.

---

Starwind UI: UI Components for Astro and More

Starwind UI is another component system in the modern frontend ecosystem. It provides styled components and accessible primitives for Astro and React, plus plain HTML, with components you add to a project and customise. (Starwind UI’s site documents the styled and primitive component sets.)

That makes it a natural fit for the kind of Astro work we do. Instead of building every component from scratch, developers start with buttons, forms, cards, navigation, dialogs, tables, feedback components, then adapt them to the project’s design system. The source lives inside the project, so control stays with the team. We use Starwind UI across our own builds, which keeps the code in your repo with no black-box components.

---

Kokonut UI: Modern React Interfaces

Kokonut UI is another component source we use when a project has React-based interfaces. It provides open-source components built around React, with Tailwind CSS and Motion, and a registry that integrates through the shadcn CLI. (Kokonut UI’s registry has the full component list.)

The collection covers modern interaction patterns and visual effects that suit SaaS dashboards, landing pages, AI applications, modern product interfaces, marketing websites, experimental UI. Saving development time is only part of the appeal. These systems also give a project a starting point for a consistent design language, which is harder to recover later than it looks.

---

TypeScript: Making JavaScript More Reliable

As projects grow, maintaining everything as loosely typed JavaScript gets difficult. TypeScript adds static typing to JavaScript, so problems surface earlier and large codebases stay easier to understand.

Instead of passing an unknown object around an application, we can define what the data should look like, and that definition travels with the code. It pays off most in APIs, database models, payment systems, dashboards, large frontend applications, shared components.

The goal here is a codebase that stays easier to maintain as the project grows, which means writing extra code only where the extra code earns its keep.

---

OpenCode and AI-Assisted Development

Software development is changing because of AI, and one tool we experiment with is OpenCode, an open-source AI coding agent that runs in the terminal. (OpenCode’s docs cover setup, agents, workflows.)

AI coding tools help with understanding an unfamiliar codebase, creating components, refactoring code, finding bugs, writing tests, explaining existing code, generating documentation, repetitive development tasks. You can also configure OpenCode with different agents and models for different workflows, which is where most of the practical value sits.

Those agents reach outside tools through MCP servers, and the same pattern underpins the customer-facing bots businesses now run, from Telegram versus WhatsApp for order bots to Discord bots paired with a local model.

Engineering judgment stays with the developer. The developer still has to review, test, secure and optimise generated code, and the person who signs it off is accountable for the architecture behind it.

---

Choosing the Right Stack

The biggest mistake in modern web development is choosing technologies because they are trending. A better approach starts with the requirements and works outward from there.

Business Website

A company website, landing page, blog, portfolio or product catalogue does well with Astro + TypeScript + CSS/Tailwind + Cloudflare. The content changes often, nothing needs a database, and the edge can serve every page as static HTML.

Interactive Web Application

Once the interface has to hold state, React + TypeScript + an API + a database makes more sense. That covers dashboards, SaaS products, admin systems, complex applications.

Full-Stack JavaScript Application

For custom applications with their own data model, React + Node.js + Express + MongoDB keeps the whole stack in one language. That suits APIs, data-heavy products, user-based applications.

E-commerce

E-commerce needs a frontend, a backend API, a database, Razorpay, with the exact implementation depending on the products, inventory, order flow, business requirements.

Cloud-Native Application

Lightweight applications that should run close to users fit Astro / React → Cloudflare Workers → Cloudflare D1.

---

Technology Should Serve the Business

There is no prize for using the most complicated technology.

If a business needs a fast catalogue website, a massive application architecture makes the project worse. If it needs a complex dashboard, static HTML is not enough. So the question worth asking is which architecture solves this problem efficiently, not which framework has the most attention, and that is the approach we follow at NKV DEV WORKS.

---

Building for Performance, Scalability, and Ownership

Our goal is not simply to make websites that look good. The underlying technology has to make sense too, which means weighing seven things before we settle on a stack:

• Performance: how quickly does the website load?
• SEO: can search engines understand and index the content?
• Accessibility: can different users read and operate the website?
• Security: are APIs, authentication, payments and data handled correctly?
• Scalability: can the architecture grow with the business?
• Maintainability: can another developer understand the code six months later?
• Ownership: can the business actually control and modify its website?

These considerations often matter more than the framework’s name. Read more in our guide to building websites that actually perform.

---

The NKV DEV WORKS Approach

We work across the layers of modern web development, and the work looks different at each one.

At the bottom sits plain HTML, CSS, JavaScript. Above that, Astro, React, TypeScript handle the interface, and behind them Node.js with APIs and databases carries the application logic. Then comes the infrastructure, Cloudflare for hosting and edge compute, and payment integrations when money is involved. Around the edges sit the modern UI systems that give a project its design language, and AI-assisted development, which changes how quickly all of it gets built.

The technology changes from project to project. The objective doesn’t: build a fast, reliable, maintainable product that solves a real business problem. Collecting technologies is not the skill. Knowing when to use each one, and when not to, is.

---

New Tools Arrive Every Year

The web development ecosystem moves quickly. New frameworks, component systems, cloud platforms, payment APIs, AI development tools appear constantly, and none of that means developers need to use everything.

The real skill is understanding the strengths and weaknesses of each technology and combining a few of them into a sensible architecture.

At NKV DEV WORKS we keep experimenting with Astro, React, MERN, Cloudflare, Razorpay, shadcn/ui, Starwind UI, Kokonut UI, TypeScript, OpenCode, while holding to one principle: technology should make the product better, not make the stack look impressive.

Want a website built with the right technology for your business? Get in touch or explore our web development services in Bangalore.