chore: add backend performance resources (#8991)

src/data/best-practices/backend-performance/content/enable-compression.md

@@ -1,3 +1,9 @@
 # Enabling Compression for Responses
 
-Optimizing the backend performance of web applications often necessitates the enablement of compression for responses. Compression methods, such as Gzip or Brotli, reduce the size of the data transmitted between the server and the client. This result in faster data transfer, minimizing the load time of the web page and improving the user experience. For instance, if a web page has a size of 100 KB, applying compression can reduce it to 30 KB. This means less data to download, hence quicker loading times. Therefore, enabling compression for responses is critical in making web applications more efficient and responsive.
+Optimizing the backend performance of web applications often necessitates the enablement of compression for responses. Compression methods, such as Gzip or Brotli, reduce the size of the data transmitted between the server and the client. This result in faster data transfer, minimizing the load time of the web page and improving the user experience. For instance, if a web page has a size of 100 KB, applying compression can reduce it to 30 KB. This means less data to download, hence quicker loading times. Therefore, enabling compression for responses is critical in making web applications more efficient and responsive.
+
+Learn more from the following resources:
+
+- [@article@Medium - Spring Microservices: Data Compression Techniques for Faster Responses](https://medium.com/@AlexanderObregon/spring-microservices-data-compression-techniques-for-faster-responses-b61d3fc6fae1)
+- [@article@Digital Ocean - Getting Started with Compression in Node.js](https://www.digitalocean.com/community/tutorials/nodejs-compression)
+- [@article@Django.Fun - Middlewares](https://django.fun/docs/django/4.2/ref/middleware/#module-django.middleware.gzip)

src/data/best-practices/backend-performance/content/pagination-large-data.md

@@ -1,3 +1,8 @@
 # Efficient Pagination for Large Datasets
 
-Backend performance in web applications can significantly be improved with efficient pagination for large datasets. When data-loaded in an application is quite extensive, executing simple queries without pagination can slow down response times, producing an adverse user experience. Through pagination, applications can deliver data in smaller, manageable chunks, reducing the amount of data transferred on each request and thereby increasing the speed and performance of the backend. For instance, instead of retrieving a million records at once, the application retrieves chunks of 50 or 100 at a time, dramatically enhancing the performance.
+Backend performance in web applications can significantly be improved with efficient pagination for large datasets. When data-loaded in an application is quite extensive, executing simple queries without pagination can slow down response times, producing an adverse user experience. Through pagination, applications can deliver data in smaller, manageable chunks, reducing the amount of data transferred on each request and thereby increasing the speed and performance of the backend. For instance, instead of retrieving a million records at once, the application retrieves chunks of 50 or 100 at a time, dramatically enhancing the performance.
+
+Learn more from the following resources:
+
+- [@article@Merge.Dev - A guide to REST API pagination](https://www.merge.dev/blog/rest-api-pagination)
+- [@article@Dev.to - Unlocking the Power of API Pagination: Best Practices and Strategies](https://dev.to/pragativerma18/unlocking-the-power-of-api-pagination-best-practices-and-strategies-4b49)

src/data/best-practices/backend-performance/content/reasonable-payload.md

@@ -1,3 +1,8 @@
 # Enforcing Reasonable Payload Size Limits
 
-Backend performance in web applications largely depends on how quickly servers are able to process, store, and retrieve data. When large data payloads are transferred, it places a heavy strain on network resources and the server itself; potentially resulting in sluggish response times and poor application performance. Hence, enforcing reasonable payload size limits is vital to maintain optimum performance. For example, a web application dealing with large image files can implement limits to ensure that users don't upload images beyond a certain size. This not only helps to keep server and bandwidth costs manageable, but also ensures that the application runs smoothly for all users.
+Backend performance in web applications largely depends on how quickly servers are able to process, store, and retrieve data. When large data payloads are transferred, it places a heavy strain on network resources and the server itself; potentially resulting in sluggish response times and poor application performance. Hence, enforcing reasonable payload size limits is vital to maintain optimum performance. For example, a web application dealing with large image files can implement limits to ensure that users don't upload images beyond a certain size. This not only helps to keep server and bandwidth costs manageable, but also ensures that the application runs smoothly for all users.
+
+Visit the following resources to learn more:
+
+- [@website@Expressjs - Fast, unopinionated, minimalist web framework for Node.js](https://expressjs.com/en/resources/middleware/body-parser.html)
+- [@website@Nginx - HTTP web server, reverse proxy, content cache, load balancer, TCP/UDP proxy server, and mail proxy server](https://nginx.org/en/docs/http/ngx_http_core_module.html#client_max_body_size)

src/data/best-practices/backend-performance/content/unnecessary-computation.md

@@ -1,3 +1,7 @@
 # Minimising Unnecessary Processing or Expensive Computation on the Server
 
-Efficient backend performance in web applications is often determined by how well unnecessary processing or expensive computations are minimised on the server. When an application is free of excess processing or complex computations, it expends less energy, executes tasks swiftly, and reduces any potential downtime. This remarkably improves the application's response time to user requests. For example, instead of calculating the same data repeatedly for different users, the application can calculate once, store the result, and then provide this stored result upon user request. This essentially minimises unnecessary processes, thereby enhancing the web application's backend performance.
+Efficient backend performance in web applications is often determined by how well unnecessary processing or expensive computations are minimised on the server. When an application is free of excess processing or complex computations, it expends less energy, executes tasks swiftly, and reduces any potential downtime. This remarkably improves the application's response time to user requests. For example, instead of calculating the same data repeatedly for different users, the application can calculate once, store the result, and then provide this stored result upon user request. This essentially minimises unnecessary processes, thereby enhancing the web application's backend performance.
+
+Learn more from the following resources:
+
+- [@video@Youtube - Caching with redis and Django](https://youtu.be/5W2Yff00H8s)