This page contains a comprehensive list of terms related to Web Performance. This list will continue to get updated.
Web Performance: Web Performance refers to the speed in which web pages are downloaded and displayed on the user's web browser. It is a critical aspect for user experience, SEO, and overall success of a website.
Web Performance Optimization: Web Performance Optimization (WPO) is the process of analyzing and improving the factors that affect a website's speed and efficiency. It includes optimizing server settings, file sizes, and code efficiency to reduce load times and improve user experience.
Mobile Friendliness: Mobile friendliness refers to how effectively a website is created and optimized to load on smartphones. It assesses how user-friendly and efficient the website's performance is on these devices. A mobile-friendly website ensures a seamless and enjoyable browsing experience for mobile users.
Google Page Experience: Google Page Experience is a set of metrics that measure how users perceive the experience of interacting with a web page beyond its pure information value. It includes factors like load time (Largest Contentful Paint), interactivity (First Input Delay), visual stability (Cumulative Layout Shift), mobile friendliness, safe browsing, HTTPS security, and no intrusive interstitials. The better the page experience, the higher the page might rank in Google's search results.
Lighthouse: Lighthouse is an open-source tool developed by Google Chrome that helps developers measure and improve the quality of web pages. It performs audits on various aspects of a website, including performance, accessibility, progressive web app capabilities, and more. Many Web Performance Testing Tools such as GTMetrix, WebPageTest, SpeedVitals, and Calibre use Lighthouse. Lighthouse has various Peformance Audits that provides suggestions on improving the page speed.
Layout: In the context of web performance, layout refers to the calculation of the position and size of all elements on a page. It's a critical step in the rendering process and can have a significant impact on performance.
DOM (Document Object Model): The DOM is a programming interface for HTML and XML documents. It represents the structure of a document and enables programmers to manipulate the content and visual presentation of webpages.
Paint: The process of rendering pixels to the screen. It involves drawing out text, colors, images, borders, and shadows, essentially every visual part of the elements.
Long Task: In web performance, a long task is any task that takes the main thread more than 50 milliseconds to complete. Long tasks can lead to unresponsiveness and a poor user experience, as they can block the main thread and prevent it from updating the UI.
Main Thread: The main thread is where a browser processes most tasks, including HTML parsing, JavaScript execution, and layout and painting. Performance issues often occur when the main thread is blocked, preventing it from responding to user input.
Render Tree: A data structure that represents the visual elements of a webpage, created by the browser during the rendering process.
Web Server: A web server is a server that hosts a website and delivers pages to users in response to their requests, which are forwarded by their computers' HTTP clients. Optimizing web server performance is crucial for web performance.
Web Hosting: Web hosting is a service that allows organizations and individuals to post a website or web page onto the Internet. The choice of web hosting service can significantly affect web performance.
Shared Hosting: A type of web hosting where multiple websites reside on a single web server. It's a cost-effective solution but can have performance limitations.
Dedicated Hosting: A type of web hosting where a client has exclusive use of an entire server. It offers better performance but is more expensive than shared hosting.
Virtual Private Server (VPS): A virtual machine sold as a service by an Internet hosting service. It runs its own copy of an operating system, and customers have superuser-level access to that operating system instance.
Performance Metrics: Performance metrics are the values that are collected during performance monitoring and testing. They include things like response time, load time, resource usage, and availability.
Web Vitals: Web Vitals is an initiative by Google to provide unified guidance for quality signals that are essential to delivering a great user experience on the web. It includes metrics like LCP, FID, and CLS.
Largest Contentful Paint (LCP): LCP measures the load speed and marks the point in the page load timeline when the page's main content has likely loaded. A good LCP score is 2.5 seconds or faster.
First Input Delay (FID): FID measures interactivity and quantifies the experience users feel when trying to interact with unresponsive pages. A good FID score is less than 100 milliseconds.
Cumulative Layout Shift (CLS): CLS measures visual stability. It quantifies the amount of unexpected layout shift of visible page content. A good CLS score is less than 0.1.
Time to First Byte (TTFB): TTFB measures the time from the user or client making an HTTP request to the first byte of the page being received by the client's browser. Lower TTFB times are preferable.
Speed Index (SI): Speed Index measures how quickly the contents of a page are visibly populated. Lower scores are better, and a score under 1000 is ideal.
First Contentful Paint (FCP): FCP measures the time from navigation to the time when the browser renders the first bit of content from the DOM. A good FCP score is around 1 second.
Total Blocking Time (TBT): Total Blocking Time (TBT) is a performance metric that quantifies the total amount of time that a page is blocked, preventing users from interacting with it. It essentially measures the total duration between First Contentful Paint (FCP) and Time to Interactive (TTI) where task execution exceeds 50ms.
Time to Interactive (TTI): TTI measures the time from navigation to the time when the main thread is quiet enough to handle user input. A good TTI score is less than 3.8 seconds.
First Meaningful Paint (FMP): A performance metric that measures the time it takes from when the page starts loading to when the primary content of a page is visible to the user.
Interaction to Next Paint (INP): Interaction to Next Paint is a Web Vital used to measure the responsiveness of a web page. It tells how quickly a Web Page responds to actions (such as a Button click).
Static Assets: Files that don't change often, like HTML, CSS, JavaScript, images, and videos. They can be cached to improve load times.
Dynamic Content: Content that changes frequently or is generated in real-time, often based on user interactions or inputs.
Critical Rendering Path (CRP): CRP is the sequence of steps the browser goes through to convert the HTML, CSS, and JavaScript into pixels on the screen. Optimizing the CRP improves render time.
HTML: HTML (HyperText Markup Language) is the standard markup language for creating web pages. It describes the structure of a web page semantically and originally included cues for the appearance of the document.
JavaScript: JavaScript is a programming language used in web development to enhance user interfaces and dynamic websites. It is crucial to web performance as inefficient JavaScript can slow down a website.
JavaScript Parsing and Execution: This is the time the browser takes to parse the JavaScript files into runnable commands, and then execute them. Reducing this time can improve web performance.
Synchronous Loading: Synchronous loading is a method where scripts are loaded one after another in the order they appear on the page. While it ensures correct execution order, it can lead to delays in page rendering, as the browser must stop and load each script before moving on.
Asynchronous Loading: Asynchronous loading is a method where scripts are loaded in the background and do not block the loading of other elements on the page. This can improve performance by not making the user wait for scripts to load before seeing other content.
Defer: Deferring JavaScript means preventing JavaScript files from loading until after the main content of the webpage has loaded. This technique improves loading speed and perceived performance for users by prioritizing content over scripts.
JSON: JavaScript Object Notation, a lightweight data-interchange format that is easy for humans to read and write and easy for machines to parse and generate.
jQuery: A fast, small, and feature-rich JavaScript library. It makes things like HTML document traversal and manipulation, event handling, and animation much simpler with an easy-to-use API.
AJAX: Asynchronous JavaScript and XML, a set of web development techniques using many web technologies on the client-side to create asynchronous web applications.
Event Listener: In JavaScript, an event listener is a procedure or function that waits for an event to occur, such as a click or a key press.
Event Handler: A callback routine that operates asynchronously and handles inputs received in a program. In JavaScript, it's often used in the context of handling user interactions such as clicks or key presses.
CSS: Cascading Style Sheets (CSS) is a style sheet language used for describing the look and formatting of a document written in HTML or XML. It impacts web performance because inefficient CSS can cause slow rendering of web pages.
Critical CSS: Critical CSS is the minimum amount of blocking CSS to render a web page. Identifying and inline-embedding critical CSS can improve web performance.
CSSOM (CSS Object Model): CSSOM is a map of all CSS selectors and relevant properties for each selector in a form that the browser can easily compute. Like the DOM, it can be manipulated via JavaScript to change the style of an HTML element.
CSS Sprites: A technique in web design where a number of images are combined into one larger image to reduce the number of HTTP requests and improve loading speed.
Web Font: Fonts that are downloaded by a browser while rendering a webpage. They allow for more design flexibility, but can impact performance if not handled properly.
Google Fonts: A library of over 800 free licensed font families, an interactive web directory for browsing the library, and APIs for conveniently using the fonts.
WOFF: Web Open Font Format, a web-specific font format that uses compression to provide lightweight files for faster load times.
WOFF2: An improvement on WOFF that provides even better compression for faster load times.
TTF: TrueType Font, a font standard developed in the late 1980s by Apple and Microsoft, widely used on both Windows and Mac platforms.
EOT: Embedded OpenType, a compact form of OpenType fonts designed by Microsoft for use as embedded fonts on web pages.
OTF: OpenType Font, a format developed by Adobe and Microsoft to bring advanced typography to computer fonts.
Image Optimization: Image optimization involves delivering high-quality images in the right format, dimension, size, and resolution while keeping the smallest possible size. It is critical to web performance as large images can slow down the website loading time.
Next-Gen Image Formats: Next-Gen Image Formats like JPEG 2000, JPEG XR, and WebP offer better compression and quality characteristics compared to older formats like JPEG and PNG. They help in improving site speed and performance by reducing the size of an image file without compromising on the quality.
JPG: A commonly used method of lossy compression for digital images, particularly for those images produced by digital photography.
PNG: A raster-graphics file-format that supports lossless data compression. PNG was developed as an improved, non-patented replacement for Graphics Interchange Format (GIF).
WebP: An image format developed by Google that provides superior lossless and lossy compression for images on the web.
SVG: Scalable Vector Graphics, a vector image format for two-dimensional graphics with support for interactivity and animation.
GIF: A bitmap image format that supports short animated sequences. It's widely used on the web for its ability to support transparency and animation.
Proxy Server: A server that acts as an intermediary for requests from clients seeking resources from other servers, providing varying levels of functionality, security, and privacy.
Reverse Proxy: A type of proxy server that retrieves resources on behalf of a client from one or more servers. It's often used for load balancing, caching, and web application security.
CDN (Content Delivery Network): A CDN is a system of distributed servers that deliver webpages and other Web content to a user based on their geographic locations, the origin of the webpage and a content delivery server. CDNs can significantly improve web performance by reducing the latency of content delivery.
CDN Fallback: CDN Fallback is a mechanism used to ensure that your web content is always available, even if the CDN (Content Delivery Network) fails. It improves reliability and hence indirectly contributes to web performance.
Critical Request: A request that is crucial for the rendering of the page. These requests should be prioritized and loaded first to ensure fast page rendering.
Critical Request Chains: The sequence of dependent network requests important for page rendering. Optimizing these chains can improve page load performance.
Render Blocking Resources: Resources that prevent a webpage from being displayed until they are fully downloaded, parsed, and executed. They can significantly impact page load speed.
Caching: Caching is a technique that stores a copy of a given resource and serves it back when requested. When a browser can reuse previously fetched resources, it can significantly enhance the speed of a website.
Server Cache: Server cache is a method used by a server to store data for faster future references. It reduces the load on the server and speeds up data retrieval by storing frequently or recently accessed information in memory or other fast-access hardware.
Browser Cache: Browser cache is a temporary storage location in your device for files downloaded by your browser to display websites. Files that are cached locally include any documents that make up a website, such as HTML files, CSS style sheets, JavaScript scripts, as well as graphic images and other multimedia content.
Cache Invalidation: The process of updating or removing the stored data in a cache when the original data is updated.
Redis Cache: Redis is an open-source, in-memory data structure store. It is often used as a database, cache, and message broker. Redis provides high performance by storing data in memory and offers various data structures such as strings, hashes, lists, sets, and more.
Memcached: Memcached is a distributed, high-performance, in-memory caching system. It is commonly used to speed up dynamic web applications by caching frequently accessed data in memory. Memcached operates as a key-value store, where data is stored and retrieved using unique keys. It helps reduce database loads and improves response times.
Minification: Minification is the process of removing unnecessary characters (like spaces and comments) from source code without changing its functionality to reduce its size, thereby improving load times.
Compression: Compression is a method used to reduce the size of files and data to improve website load times. Two commonly used types of compression on the web include GZIP and Brotli.
Lossy Compression: A data encoding method that compresses data by discarding (losing) some of it. The procedure aims to minimize the amount of data that needs to be held, handled, and/or transmitted by a computer.
Lossless Compression: A method of data compression in which the original data can be perfectly reconstructed from the compressed data. This is in contrast to lossy compression, which does not allow the exact original data to be reconstructed from the compressed data.
GZip: A file format and software application used for file compression and decompression. On the web, it's used to reduce the size of data that's being transferred, improving load times and reducing bandwidth usage.
Brotli: A compression algorithm developed by Google, used to reduce the size of transmitted data, which can improve web performance.
HTTP Request: An HTTP request is made by a client to a server to access a particular resource on the web. Reducing the number of HTTP requests can improve web performance.
HTTP Response: An HTTP response is the server's response to an HTTP request. The speed of these responses is crucial for fast page load times.
Request Header: Part of the HTTP request where additional information is sent to the server, such as the browser type and language preferences.
Response Header: Part of the HTTP response where the server sends additional information about the response, like its location and server name.
HTTP Status Code: HTTP Status Codes are three-digit responses that a server returns after processing a client's request. They provide information about the success or failure of the requested operation, and help in diagnosing issues when a web page or other resource does not load properly.
HTTP Status 100 Series (Informational): These codes indicate that the server received the request and the process is continuing. For example, 100 (Continue) means the initial part of the request has been received and the client should continue to send the rest of the request.
HTTP Status 200 Series (Success): These codes indicate that the request was successfully received, understood, and accepted. For example, 200 (OK) is the standard response for successful HTTP requests.
HTTP Status 300 Series (Redirection): These codes indicate that further action needs to be taken in order to complete the request. For example, 301 (Moved Permanently) means the URL of the requested resource has been changed permanently.
HTTP Status 400 Series (Client Error): These codes are intended for situations in which the client seems to have erred. For example, 404 (Not Found) means the requested resource could not be found on the server.
HTTP Status 500 Series (Server Error): These codes indicate the server failed to fulfill an apparently valid request. For example, 500 (Internal Server Error) means the server encountered an unexpected condition which prevented it from fulfilling the request.
HTTP/1.1: The version of HTTP that includes improvements to the original HTTP/1.0, such as persistent connections, chunked transfer-coding, and additional cache control mechanisms.
HTTP/2: HTTP/2 is a major revision of the HTTP protocol used by the World Wide Web. It allows servers to push responses proactively into client caches instead of waiting for a new request for each resource, improving web performance.
HTTP/3: The third version of the Hypertext Transfer Protocol (HTTP), which is used for data communication on the World Wide Web. HTTP/3 uses QUIC, a transport layer protocol, which reduces latency and improves speed by using UDP instead of TCP.
HTTPS: Hypertext Transfer Protocol Secure, an extension of HTTP. It's used for secure communication over a computer network, and is widely used on the Internet.
SSL/TLS: SSL (Secure Sockets Layer) and its successor, TLS (Transport Layer Security), are protocols for establishing authenticated and encrypted links between networked computers. While they are important for security, they can impact web performance.
Lab Data: Data collected in a controlled environment with predefined device and network settings. It offers reproducible results and debugging capabilities.
Field Data: Field data refers to the real-world performance data of a webpage, collected from actual users interacting with the website. It provides insights into how users experience the site, including load times, interactivity, and visual stability.
Chrome UX Report: The Chrome User Experience Report (CrUX) is a public dataset provided by Google that aggregates user experience metrics across millions of websites. It provides real-world, user-centered metrics like load time and interactivity.
Lazy Loading: Lazy loading is a design pattern commonly used in computer programming that defers initialization of an object until the point at which it is needed. In the context of web performance, it can be used to delay loading certain parts of a webpage, such as images or scripts, until they are needed.
Domain Sharding: Domain sharding is a technique for splitting resources across multiple domains to allow browsers to download more resources simultaneously, thereby increasing page speed.
Resource Hints: Resource hints are a way for developers to give the browser information about which resources should be fetched or preprocessed to improve page load performance.
Server Response Time (SRT): SRT refers to the amount of time it takes for the server to respond to a browser request. Reducing this time can improve web performance.
Preloading: Preloading is a technique where certain files are loaded in the initial page load, even before they are required, so they can be used immediately when needed.
Prefetching: Prefetching is a technique where resources are loaded in the background while the user is browsing so they are ready to be displayed when needed.
Prerendering: Prerendering is a technique where pages are rendered in advance of being needed so they can be displayed instantly.
Round Trip Time (RTT): RTT is the time it takes for a packet of data to go from the sender to the receiver and back. Reducing RTT can improve web performance.
Packet Loss: Packet loss refers to data that is transmitted but never arrives at its destination. Reducing packet loss can improve web performance.
AMP (Accelerated Mobile Pages): AMP is a web component framework and a website publishing technology developed by Google which has the mission to provide a user-first format for web content. AMP optimizes mobile web browsing and intends to improve web performance.
DNS Lookup: DNS Lookup is the process used to resolve human-readable web addresses into machine-readable IP addresses. Fast DNS lookup times improve web performance by reducing the time it takes for a client to reach the server hosting the website.
TCP Handshake: This is the initial setup of a TCP connection where client and server exchange SYN (synchronization) and ACK (acknowledgement) messages to establish connection parameters. A shorter handshake process can lead to improved web performance.
Latency: Latency is the delay between a user's action and a web application’s response to that action, often referred to as lag. Reducing latency can significantly improve a website's performance.
Bandwidth: Bandwidth is the maximum rate of data transfer across a given path. Greater bandwidth can lead to faster loading times.
Rendering: Rendering is the process by which a browser converts code into a viewable website. The speed at which this happens impacts web performance.
Progressive Rendering: Progressive rendering is a technique to display content as soon as it is available, improving perceived performance.
Viewport: The viewport is a user's visible area of a web page, which varies with the device used. Designing and optimizing for the viewport can improve both mobile and desktop performance.
Adaptive Design: Adaptive design is a user interface design strategy that adapts to the user's device or environment. It can improve web performance by delivering optimized experiences based on the user's device.
Responsive Design: Responsive design is an approach to web design that makes web pages render well on a variety of devices and window or screen sizes. It improves user experience and performance.
UX (User Experience): UX encompasses all aspects of the end-user's interaction with a company, its services, and its products. Good UX design can improve web performance from the user's perspective.
Bounce Rate: Bounce rate is the percentage of users who land on a website and do nothing on the page they entered. A high bounce rate can indicate poor web performance.
Load Testing: Load testing is a type of performance testing that simulates real-world load on any software, application, or website to check its performance under peak load conditions.
Stress Testing: Stress testing is a type of performance testing that checks the robustness of a website under extreme conditions. It helps identify the breakpoint of an application.
Server-side Rendering (SSR): SSR is a popular technique for rendering a normally client-side only single page app (SPA) on the server and then sending a fully rendered page to the client. It can improve performance especially on slow networks or low-end devices.
Client-side Rendering (CSR): CSR is an approach where the browser downloads the minimal HTML of a page, renders the JavaScript, and then fills in the content. While this approach can be slower initially, it can provide a faster subsequent interaction.
Static Site Generation (SSG): SSG is a rendering method that generates static HTML pages at build time. It's known for its fast delivery, high reliability, and ease of deployment.
Dynamic Rendering: Dynamic rendering is a technique for serving a pre-rendered, static HTML snapshot of a page to web crawlers and a normal client-side rendered version to users. This is especially useful for SEO and improving website visibility.
Front-end Optimization (FEO): FEO is the process of optimizing the delivery of website resources from the server to the browser, with the aim of making the website display as quickly as possible to the end user.
Back-end Optimization: Back-end optimization involves improving the server's performance by optimizing the way it processes requests and responses.
Throughput: Throughput is the number of transactions a server can handle in a given amount of time. It is a key metric for measuring the performance of servers.
Database Optimization: Database optimization is the process of configuring and tuning the database to achieve optimal performance. It involves tasks like query optimization, index tuning, and disk optimization.
Query Optimization: Query optimization is a function of many relational database management systems, where multiple query plans for satisfying a query are examined and a good-enough plan is chosen. It can dramatically improve the speed and efficiency of database operations.
Indexing: In the context of databases, indexing is a data structure technique to enhance the speed of retrieval operations on a database table. Proper indexing can vastly speed up data retrieval times.
Web Performance Monitoring: Web performance monitoring is the process of checking the performance of web components like servers, network, APIs, applications, and more in real time. It helps in identifying any performance issues and rectifying them for optimal user experience.
Real-User Monitoring (RUM): RUM is a form of passive web monitoring where data is collected directly from users' web browsers to understand user interaction patterns and their experience, including perceived load speed, error occurrences, and the impact of browser types.
Synthetic Monitoring: Synthetic monitoring, also known as proactive monitoring or synthetic testing, is a method where a series of predefined actions are simulated on a web application, such as completing a checkout process or filling out a form, to monitor for performance and functionality issues.
Synthetic Testing: Synthetic testing is an approach aimed at gaining insights into the user experience of your application by anticipating and simulating their behavior.
Baseline Testing: Baseline testing refers to the process of running a set of tests to capture performance information. This information serves as a point of reference or baseline against which all future tests can be compared.
Benchmark Testing: Benchmark testing is the process of comparing your website performance against the performance of other sites, either competitors or industry leaders. This helps you understand where you stand and what you need to aim for.
APDEX (Application Performance Index): APDEX is a simplified SLA and KPI measurement for the performance of software applications in computing. It converts many measurements into one number on a uniform scale of 0-to-1 (0 = no users satisfied, 1 = all users satisfied).
Uptime: Uptime is the time during which a machine, especially a computer, is in operation. In the context of web performance, uptime often refers to the long-term reliability of web servers and internet connections.
Downtime: Downtime is the time during which a machine, especially a computer, is out of action or unavailable for use. In web performance monitoring, minimizing downtime is critical.
Availability: In the context of web performance monitoring, availability refers to the accessibility of a website or web service. It's typically measured as a percentage, with the goal of reaching 100% availability, or never going down.
Error Rate: Error rate refers to the number of errors that occur on a website over a specific period. This can include 404 errors, server errors, and other issues that prevent a user from accessing a web page.
Capacity Testing: Capacity testing is similar to stress and load testing but focuses on learning the upper limit capacity of the system under specific load conditions and how it handles peak loads in terms of response times.
Server Monitoring: Server monitoring is the process of reviewing and analyzing a server for availability, operations, performance, security, and other operations-related processes. It helps in identifying any potential issues and rectifying them for optimal performance.
API Monitoring: API monitoring involves the testing and monitoring of the status, functionality, and performance of APIs. It helps to ensure that the APIs that connect your application to third-party services are running smoothly and efficiently.
DOMContentLoaded: An event that fires when the initial HTML document has been completely loaded and parsed, without waiting for stylesheets, images, and subframes to finish loading.
Onload: An event that fires when the whole page, including all dependent resources such as stylesheets and images, has been completely loaded.
Web Workers: A JavaScript feature that allows web applications to run background threads concurrently with the main execution thread, improving performance for complex operations.
Waterfall: In web performance, a waterfall is a graphical representation of the loading sequence and timing for each resource on a webpage.
Above the Fold: Refers to the portion of a webpage that is visible without scrolling. It's important for web performance as users expect this content to load quickly.
Below the Fold: The portion of a webpage that becomes visible only when the user scrolls down. This content can be loaded later for performance optimization.
CMS: A Content Management System (CMS) is a software application that allows users to build and manage a website without needing to code it from scratch. It provides a user-friendly interface to create, edit, and manage digital content.
WordPress: WordPress is a popular open-source CMS that allows users to create and manage websites. It offers a wide range of themes and plugins, making it a versatile platform for blogs, business sites, and online stores. Check out the WordPress Performance Checklist to learn the Optimization Tips.
DNS: Domain Name System, the phonebook of the internet. It translates domain names to IP addresses so browsers can load Internet resources.
TLS Handshake: The process that establishes a secure connection between a client and a server using the Transport Layer Security (TLS) protocol.
Redirect: A way to send both users and search engines to a different URL from the one they originally requested. While sometimes necessary, redirects can slow down page load speed.
Redirect Chain: A series of redirects from one URL to another. Too many redirects can slow down page load speed and negatively impact user experience.
Mobile First Design: A design strategy that starts by designing for the smallest screen sizes first and then progressively enhancing the design for larger screens.
Desktop First Design: A design strategy that starts with designing for larger screens first, and then scales down and optimizes for smaller screens.
URL: Uniform Resource Locator, the address used to access resources on the internet.
User Agent: A string that the browser sends to the server to identify itself, including information about the browser version and operating system.
Application Performance Monitoring (APM): A method used to monitor and manage the performance and availability of software applications.
Combining Files: The process of merging multiple files into one, often used in the context of CSS or JavaScript files to reduce the number of HTTP requests and improve load times.
Etag: An identifier assigned by a web server to a specific version of a resource found at a URL. If the resource content at that URL ever changes, a new and different ETag is assigned.
Load Balancing: Load balancing is a process that distributes network or application traffic across a number of servers to ensure no single server bears too much demand. This helps in achieving optimal resource utilization, maximizing throughput, minimizing response time, and avoiding overload.
Scalability: The ability of a system, network, or process to handle a growing amount of work in a capable manner or its ability to be enlarged to accommodate that growth.
Scalability Testing: Scalability testing is a type of testing to check whether a web application can handle the expected number of users, and how it manages when scaled up with increasing users or transactions. It helps in identifying the maximum work a system can handle without significant performance degradation.
Performance Budget: A performance budget is a set of limits concerning certain metrics that affect website performance, which should not be exceeded in the design and development process. It helps in maintaining site performance by setting boundaries on elements like page weight, load time, or the number of HTTP requests.
Angular: A TypeScript-based open-source web application framework led by the Angular Team at Google. It's used to build single-page applications and dynamic websites.
React: A JavaScript library developed by Facebook for building user interfaces, particularly for single-page applications. It allows developers to create reusable UI components.
Vue: A progressive JavaScript framework used to build user interfaces. Unlike other monolithic frameworks, Vue is designed from the ground up to be incrementally adoptable.
Svelte: A new way to build web applications. It's a compiler that takes your declarative components and converts them into efficient JavaScript that surgically updates the DOM.
Ember.js: A JavaScript framework that allows developers to build scalable single-page web applications by incorporating common idioms and best practices into the framework.
Meteor.js: A full-stack JavaScript platform for developing modern web and mobile applications. Meteor includes a key set of technologies for building connected-client reactive applications.
Backbone.js: Provides structure to web applications by offering models with key-value binding and custom events, collections with a rich API of enumerable functions, and views with declarative event handling.
Preact: A fast 3kB alternative to React with the same modern API. It's used for building user interfaces.
Polymer: An open-source JavaScript library for building web applications using Web Components. The library is being developed by Google developers and contributors on GitHub.
Django: A high-level Python web framework that encourages rapid development and clean, pragmatic design. It follows the model-view-template architectural pattern.
Ruby on Rails: A server-side web application framework written in Ruby. Rails is a model-view-controller (MVC) framework, providing default structures for a database, a web service, and web pages.
PHP: A popular general-purpose scripting language that is especially suited to web development. It can be embedded into HTML.
Laravel: A web application framework with expressive, elegant syntax. It attempts to take the pain out of development by easing common tasks used in most web projects, such as authentication, routing, sessions, and caching.
Spring Boot: An open-source Java-based framework used to create a microservice. It provides a flexible way to configure Java Beans, XML configurations, and Database Transactions.
Next.js: A React framework that enables functionality such as server-side rendering and generating static websites for React-based web applications. You should check out Next.js Performance Checklist to optimize Next.js Apps.
NestJS: A framework for building efficient, scalable Node.js server-side applications. It uses progressive JavaScript, is built with TypeScript, and combines elements of OOP, FP, and FRP.
SvelteKit: A framework built around Svelte, aiming to make it easier to build Svelte applications. It provides features like server-side rendering, routing, and more out of the box.
Express.js: A minimal and flexible Node.js web application framework that provides a robust set of features for web and mobile applications.
Nuxt.js: A Vue.js meta-framework for universal applications. It simplifies the development of universal or single-page Vue apps.
Sails.js: A real-time MVC framework for Node.js that makes it easy to build custom, enterprise-grade Node.js apps.
Flask: A micro web framework written in Python. It does not include
ASP.NET: A framework for building web apps and services with .NET and C#. It supports industry-standard authentication protocols and has built-in features for maintaining and managing user accounts.
FastAPI: A modern, fast (high-performance), web framework for building APIs with Python 3.6+ based on standard Python type hints. It's easy to use and has automatic interactive API documentation.
Gatsby: A React-based open-source framework for creating websites and apps. It's great for creating static sites, but also supports dynamic data updates, making it a hybrid framework.