Remember what the internet was like in 2015? Back then, we were just getting used to responsive websites that displayed properly on smartphones. Today, web applications can compete with real computer programs. Let’s take a look at what has happened over the past ten years and how technology has completely changed the way modern websites and web applications are created.
From simple pages to complex applications
Ten years ago, most websites were pretty simple. You opened a page, and it loaded in its entirety. If you wanted to go to another page, you had to reload the entire page again. It was slow and not very convenient, especially with slow internet connections.
Today, many websites function as full-fledged applications. Open Gmail, Twitter, or Facebook, and you will notice that the page does not reload completely with every action. Content is updated instantly, and everything works smoothly and quickly. This has been made possible by the concept of Single Page Applications, or SPAs.
Instead of requesting a new HTML page from the server every time, modern web applications download it once and then simply update the necessary parts of the interface. It’s like the difference between switching TV channels (a sudden transition) and scrolling through your Instagram feed (a smooth content update).
JavaScript has taken over the world
If JavaScript used to be a language for simple animations and form validation, today it is a true giant of web development. Over the past ten years, it has evolved from a “toy” language into a powerful tool used to write everything from small websites to huge corporate systems.
The main change occurred in 2015, when the ES6 (ECMAScript 2015) standard was released. It was revolutionary. The language gained many features that it had been lacking: normal class handling, arrow functions, promises for working with asynchronous code, and destructuring of objects and arrays. The code became cleaner, clearer, and easier to write.
For example, previously, to write a simple function, you had to write it like this:
var multiply = function(a, b) { return a * b;
}
And now you can do this:
const multiply = (a, b) => a * b;
In short, clearer, more elegant. And there were hundreds of such improvements.
Frameworks: React, Vue, and Angular are changing the rules of the game
One of the most significant changes in recent years has been the emergence and development of JavaScript frameworks. The three main players in this field—React, Vue, and Angular—have changed the way we create interfaces.
React appeared back in 2013, but it has only become truly popular in the last ten years. It was created at Facebook (now Meta), and the main idea was simple: break the interface down into independent components, like Lego bricks. Each component is a brick that can be reused. A button, a search form, a product card—these are all components that are easy to combine and reuse.
Vue.js has become a crowd favorite thanks to its simplicity. It was created by a single developer, Evan You, and is a great example of how an open-source project can compete with developments from large corporations. Vue took the best from Angular and React, but made everything simpler and more understandable for beginners.
Angular from Google is a more rigorous and structured framework. It is ideal for large corporate projects that require a rigid architecture and clear rules. Angular 2 was released in 2016, completely rewritten from scratch, and it was like switching from a regular phone to a smartphone.
These frameworks have taught us to think about web development in a new way. Now we don’t just write code that does something—we create reusable components, think about the state of the application, and consider data flows.
TypeScript: JavaScript on steroids
Another important change is the widespread adoption of TypeScript. This is an extension of JavaScript that adds typing. It sounds boring, but in practice it saves a huge amount of time and nerves.
Imagine you are writing a function that should accept a number. In regular JavaScript, you could accidentally pass a string to it, and the error would only show up when the program is running, possibly already at the user’s end. TypeScript, on the other hand, will check the types while you are writing the code and say, “Wait, you’re passing the wrong thing!”
In recent years, TypeScript has become the de facto standard for serious projects. Even those who were previously skeptical of it began to understand its value as projects grew.
Node.js and JavaScript on the server
Previously, there was a clear division: JavaScript was for browsers, while PHP, Ruby, Python, or Java were for servers. Node.js has blurred this line. Now, a single developer can write both the client and server sides in one language.
Node.js appeared in 2009, but its heyday came in the last decade. Today, Netflix, LinkedIn, Uber, and thousands of other services run on it. Its main advantage is asynchronous processing and high performance when working with multiple simultaneous connections.
This has given rise to a whole ecosystem of tools: Express.js for creating APIs, Socket.io for working with real-time web sockets, and Nest.js for building scalable server applications. JavaScript is no longer just a browser language—it has become a full-fledged tool for creating any kind of application.
CSS has also grown
While everyone was admiring JavaScript, CSS wasn’t standing still either. Flexbox and Grid Layout changed the way we create page layouts. Previously, to make elements in a row with the same height, you had to mess around with floats and clearfixes. Now, all you need to do is write display: flex and a few simple properties.
CSS Grid has gone even further, allowing you to create complex two-dimensional grids without a single line of JavaScript. What used to require Bootstrap or Foundation can now be done with a few lines of pure CSS.
CSS variables (custom properties) have been introduced, allowing you to create themes and switch colors with a single command. New units of measurement such as vw and vh have been added, helping to create truly responsive interfaces.
Preprocessors such as SASS and LESS have made writing CSS more structured and convenient. You can use variables, nesting, mixins—everything that was missing in regular CSS.
The emergence of CSS-in-JS
An interesting trend in recent years is CSS-in-JS, where styles are written directly in JavaScript code. Libraries such as styled-components and Emotion allow you to create styled components where logic and design are in one place.
This may seem strange, but in practice it is very convenient: all component styles are located next to its logic, there are no problems with class name conflicts, and styles can be dynamically changed based on props. However, not everyone likes this—there are supporters of a more traditional approach.
Webpack, build tools, and utilities
Modern web development is unthinkable without build tools. Webpack has become the industry standard, although it now has competitors such as Parcel, Rollup, and more recently, Vite and esbuild, which are significantly faster.
Builders solve many problems: they combine multiple files into one, minify code, transcompile modern JavaScript into older versions to support older browsers, optimize images, and enable the use of modules. Previously, all of this was done manually or not at all, but now it is done automatically.
Tools for code quality control have appeared: ESLint checks code for errors and compliance with standards, while Prettier automatically formats code, making it uniform. This is especially important in teams where dozens of developers work.
Git and collaborative development
GitHub, GitLab, and Bitbucket have made collaborative development enjoyable. Pull requests, code reviews, and continuous integration have all become the norm. Previously, code was uploaded to the server via FTP, and one hoped that nothing would break. Now, every change is reviewed, tested automatically, and merged into the main branch only after approval.
Practices such as trunk-based development have emerged, where everyone works in a single branch, making small, frequent commits. Or Git Flow, with a clear branch structure for development, testing, and releases.
APIs and microservices
The approach to application architecture has also changed. Previously, there was a monolith—one large application that did everything. Now, microservices are in vogue—small, independent services, each of which performs its own task.
REST API has become the standard for front-end interaction with back-end. In recent years, GraphQL, a query language for APIs developed by Facebook, has been gaining popularity. Its main advantage is that the client specifies what data they need, without unnecessary fields and queries.
Concepts such as serverless and functions as a service (AWS Lambda, Google Cloud Functions) have emerged. Now there is no need to set up an entire server—you can write a function that runs only when needed and charges only for the time it takes to execute.
Progressive Web Apps: websites as applications
PWA, or Progressive Web Apps, is a technology that transforms regular websites into native applications. They can work offline, send push notifications, and be installed on your desktop or phone home screen.
Twitter, Uber, Pinterest—many companies have created PWA versions of their services. This is cheaper than developing separate apps for iOS and Android, and is immediately accessible to all users via a browser.
Service Workers, a key PWA technology, allow you to cache resources and work with them offline. Got on the subway without internet? No problem—the PWA app will continue to work, displaying cached content.
WebAssembly: performance at a new level
WebAssembly, or WASM, is a real breakthrough. It is a binary format that runs in the browser at near-native speed. Now you can run games, video editors, and 3D applications in your browser—things that were previously impossible due to JavaScript limitations.
Figma, a popular design tool, runs in a browser thanks to WebAssembly. AutoCAD has launched a web version. Even Adobe Photoshop has appeared in a browser. This would have been unthinkable ten years ago.
WASM allows code written in C++, Rust, or other languages to be used directly in the browser. This opens up completely new possibilities for web applications.
Mobile development using web technologies
React Native and Flutter have changed the approach to mobile development. Now it is not necessary to learn Swift and Kotlin—you can write applications in JavaScript or Dart and get native applications for iOS and Android.
React Native uses the same concepts as React for the web, but instead of HTML, it creates native components. Instagram, Facebook, Discord—many popular applications are written in React Native.
Ionic and Capacitor took a different approach—they allow you to package a web application into a native application shell. This is simpler, but slightly slower than React Native.
Jamstack and static generators
Jamstack architecture has changed the approach to website development. The idea is simple:
Generate static HTML during the build phase, rather than with each request. This is faster, safer, and cheaper in terms of hosting.
Next.js for React, Nuxt.js for Vue, Gatsby—these frameworks allow you to create static websites with dynamic capabilities. You can generate pages in advance and load data dynamically.
Netlify, Vercel, and GitHub Pages make deploying such sites as easy as possible. Once the code is committed to Git, the site is automatically rebuilt and deployed. No servers or complex settings are required.
Testing has become mandatory
Testing used to be a luxury. Now it’s a necessity. Jest, Mocha, Cypress, Playwright—there are now many testing tools available, and they have become much easier to use.
Test-Driven Development (TDD) is no longer considered exotic. Many teams write tests first, then code. This helps avoid bugs and makes the code more reliable.
Continuous Integration automatically runs tests with every commit. If something breaks, you get notified immediately. No need to manually check every change.
Accessibility and inclusiveness
Accessibility, or a11y, has become an important topic. Developers have begun to think about how people with disabilities use their websites: blind people with screen readers, people with motor impairments, and people with color blindness.
WCAG standards, accessibility testing libraries, and tools such as Lighthouse, which evaluate website accessibility, have emerged. Many companies will now not launch a website into production if it does not meet accessibility standards.
Dark theme and customization
Dark themes have become a trend in recent years. Almost every website and app now offers a dark mode. CSS has gained the prefers-color-scheme media query, which automatically determines user preferences.
It’s not just a trend—dark themes actually reduce eye strain, save battery life on OLED screens, and are simply preferred by many users.
Containerization and Docker
Docker has changed how we deploy applications. Instead of installing all dependencies on the server, everything is packaged into a container—an isolated environment with everything you need. “It works on my machine” is no longer an issue.
Kubernetes for container orchestration has become the standard for large projects. You can automatically scale your application depending on the load, restore crashed containers, and perform smooth updates without downtime.
Performance above all else
Google has started to take website loading speed into account in its rankings. CoreWeb has appeared.
Vitals are metrics that measure the actual user experience. LCP (Largest Contentful Paint), FID (First Input Delay), CLS (Cumulative Layout Shift) — these abbreviations have become part of every web developer’s vocabulary.
Lazy loading, code splitting, image optimization, critical CSS – optimization techniques have become standard practice. Users are not willing to wait – if a website takes longer than three seconds to load, they leave.
The future is already here
The last ten years have been incredibly eventful in web development. What seemed like science fiction in 2015 is now commonplace. And this is just the beginning.
WebGPU for graphics, Web Bluetooth and Web USB for device interaction, WebXR for virtual and augmented reality – browsers are gaining more and more capabilities.
Artificial intelligence is beginning to penetrate web development. GitHub Copilot writes code alongside you, GPT models generate content, and machine learning works directly in the browser thanks to TensorFlow.js.
Web development has evolved from creating simple websites into a true engineering discipline. Modern web developers must be knowledgeable about a variety of technologies, understand architecture, be able to work in a team, test code, and consider performance and accessibility.
But despite all the complexity, the barrier to entry into the profession has become lower. A huge amount of training materials, open-source projects, and frameworks with good documentation make web development accessible to anyone who is willing to learn.
And the most interesting thing is that this is not the end, but rather the middle of the journey. The next ten years promise to be even more exciting!