add content links to api-design roadmap (#6305)

* add content links to api-design roadmap

* complete api-design roadmap content

* Apply suggestions from code review

fix styling

src/data/roadmaps/api-design/content/api-gateways@MJeUD4fOHaJu1oxk4uQ-x.md

@@ -1,3 +1,8 @@
 # API Gateways
 
-API Gateways act as the main point of entry in a microservices architecture, often responsible for request routing, composition, and protocol translation. They play a significant role in API design by providing a shared layer to handle non-business tasks. This not only simplifies how consumers interact with the backend services but also helps in maintaining the security, enforcing policies, and providing analytics over the API usage. When designing APIs, understanding and implementing efficient API Gateways is an invaluable skill, as these gateways form a crucial component of any well-structured, scalable API architecture.
+API Gateways act as the main point of entry in a microservices architecture, often responsible for request routing, composition, and protocol translation. They play a significant role in API design by providing a shared layer to handle non-business tasks. This not only simplifies how consumers interact with the backend services but also helps in maintaining the security, enforcing policies, and providing analytics over the API usage. When designing APIs, understanding and implementing efficient API Gateways is an invaluable skill, as these gateways form a crucial component of any well-structured, scalable API architecture.
+
+Learn more from the following resources:
+
+- [@article@What does an API Gateway do?](https://www.redhat.com/en/topics/api/what-does-an-api-gateway-do)
+- [@article@What are API Gateways?](https://www.ibm.com/blog/api-gateway/)

src/data/roadmaps/api-design/content/api-integration-patterns@R3aRhqCslwhegMfHtxg5z.md

@@ -1,3 +1,8 @@
 # API Integration Patterns
 
-API Integration Patterns, in the context of API Design, refers to the common paradigms and approaches used to enable communication between services. These patterns dictate how different APIs interact and exchange data, allowing software applications to work cohesively. They play a vital role in application development by providing a standard method for connecting diverse software components. By understanding and implementing these patterns, developers can design more robust, scalable, and interoperable APIs.
+API Integration Patterns, in the context of API Design, refers to the common paradigms and approaches used to enable communication between services. These patterns dictate how different APIs interact and exchange data, allowing software applications to work cohesively. They play a vital role in application development by providing a standard method for connecting diverse software components. By understanding and implementing these patterns, developers can design more robust, scalable, and interoperable APIs.
+
+Learn more from the following resources:
+
+- [@article@API Integration Patterns - Dzone](https://dzone.com/refcardz/api-integration-patterns)
+- [@article@API Integration Patterns](https://uk.devoteam.com/expert-view/api-integration-patterns/)

src/data/roadmaps/api-design/content/api-keys--management@tzUJwXu_scwQHnPPT0oY-.md

@@ -1,3 +1,8 @@
 # API Keys & Management
 
-API keys and management is an integral part of API design. An API key is a unique identifier used to authenticate a user, developer, or calling program to an API. This ensures security and control over API endpoints, as only those with a valid API key can make requests. API Management, on the other hand, refers to the practices and tools that enable an organization to govern and monitor its API usage. It involves all the aspects of managing APIs including design, deployment, documentation, security, versioning, and analytics. Both elements play crucial roles in securing and organizing API access for efficient and controlled data sharing and communication.
+API keys and management is an integral part of API design. An API key is a unique identifier used to authenticate a user, developer, or calling program to an API. This ensures security and control over API endpoints, as only those with a valid API key can make requests. API Management, on the other hand, refers to the practices and tools that enable an organization to govern and monitor its API usage. It involves all the aspects of managing APIs including design, deployment, documentation, security, versioning, and analytics. Both elements play crucial roles in securing and organizing API access for efficient and controlled data sharing and communication.
+
+Learn more from the following resources:
+
+- [@article@What is API key management?](https://www.akeyless.io/secrets-management-glossary/api-key-management/)
+- [@article@API Key Management | Definition and Best Practices](https://infisical.com/blog/api-key-management)

src/data/roadmaps/api-design/content/api-lifecycle-management@At5exN7ZAx2IzY3cTCzHm.md

@@ -1,3 +1,9 @@
 # API Lifecycle Management
 
-API Lifecycle Management is a crucial aspect in API design that oversees the process of creating, managing, and retiring APIs. This involves various stages from initial planning, designing, testing, deployment, to eventual retirement of the API. Proper lifecycle management ensures that an API meets the requirements, is reliable, and that it evolves with the needs of end users and developers. Moreover, it helps in maintaining the security, performance, and accessibility of the API throughout its lifetime. This comprehensive approach enables organizations to make the most of their APIs, mitigate issues, and facilitate successful digital transformation.
+API Lifecycle Management is a crucial aspect in API design that oversees the process of creating, managing, and retiring APIs. This involves various stages from initial planning, designing, testing, deployment, to eventual retirement of the API. Proper lifecycle management ensures that an API meets the requirements, is reliable, and that it evolves with the needs of end users and developers. Moreover, it helps in maintaining the security, performance, and accessibility of the API throughout its lifetime. This comprehensive approach enables organizations to make the most of their APIs, mitigate issues, and facilitate successful digital transformation.
+
+Learn more from the following resources:
+
+- [@article@What is the API lifecycle?](https://www.postman.com/api-platform/api-lifecycle/)
+- [@article@What is API lifescycle management?](https://swagger.io/blog/api-strategy/what-is-api-lifecycle-management/)
+- [@video@Day in the lifecycle of an API](https://www.youtube.com/watch?v=VxY_cz0VQXE)

src/data/roadmaps/api-design/content/api-performance@d9ZXdU73jiCdeNHQv1_DH.md

@@ -1,3 +1,8 @@
 # API Performance
 
-When we talk about API design, one crucial aspect that demands our attention is API Performance. API Performance refers to the efficiency and speed at which a developed API can execute tasks and communicate with other programs or software components. This fundamental aspect can directly impact the responsiveness of an application, determining how quickly data can be exchanged, processed, and presented to the end-user. Improving the API performance often resolves problems related to the user experience and enhances the overall performance of the application that the API is integrated with. API performance, therefore, plays a pivotal role both in facilitating optimized interactions between systems and in determining the overall success of the digital products that rely on such interfaces.
+When we talk about API design, one crucial aspect that demands our attention is API Performance. API Performance refers to the efficiency and speed at which a developed API can execute tasks and communicate with other programs or software components. This fundamental aspect can directly impact the responsiveness of an application, determining how quickly data can be exchanged, processed, and presented to the end-user. Improving the API performance often resolves problems related to the user experience and enhances the overall performance of the application that the API is integrated with. API performance, therefore, plays a pivotal role both in facilitating optimized interactions between systems and in determining the overall success of the digital products that rely on such interfaces.
+
+Learn more from the following resources:
+
+- [@video@Top 7 Ways to 10x Your API Performance](https://www.youtube.com/watch?v=zvWKqUiovAM)
+- [@article@10 Tips for Improving API Performance](https://nordicapis.com/10-tips-for-improving-api-performance/)

src/data/roadmaps/api-design/content/api-testing@Wpk4TvxcZOJgAoXjrOsZF.md

@@ -1,3 +1,8 @@
 # API Testing
 
-API Testing refers to the process of checking the functionality, reliability, performance, and security of Application Programming Interfaces (APIs). It plays a crucial role in API design as it ensures that the APIs work correctly and as expected. This kind of testing does not require a user interface and mainly focuses on the business logic layer of the software architecture. API Testing is integral to guarantee that the data communication and responses between different software systems are error-free and streamlined.
+API Testing refers to the process of checking the functionality, reliability, performance, and security of Application Programming Interfaces (APIs). It plays a crucial role in API design as it ensures that the APIs work correctly and as expected. This kind of testing does not require a user interface and mainly focuses on the business logic layer of the software architecture. API Testing is integral to guarantee that the data communication and responses between different software systems are error-free and streamlined.
+
+Learn more from the following resources:
+
+- [@article@What is API testing?](https://www.postman.com/api-platform/api-testing/)
+- [@article@API Testing : What It is, How to Test & Best Practices](https://testsigma.com/guides/api-testing/)

src/data/roadmaps/api-design/content/attribute-based-access-control-abac@dZTe_kxIUQsc9N3w920aR.md

@@ -1,3 +1,8 @@
 # Attribute Based Access Control (ABAC) - An Authorization Method in API Design
 
-Attribute Based Access Control (ABAC) is a flexible and powerful authorization method in the realm of API Design. Distinct from Role-Based Access Control (RBAC), which relies on predefined roles and permissions, ABAC uses attributes to build policies and make decisions. These attributes can be associated with the user, the action they want to perform, targeted resources, or the environment. With ABAC, finer-grained access control can be achieved, thereby improving the security and efficiency of APIs. This approach is widely used in complex and dynamic environments where access control requirements can be multifaceted and deeply context-dependent.
+Attribute Based Access Control (ABAC) is a flexible and powerful authorization method in the realm of API Design. Distinct from Role-Based Access Control (RBAC), which relies on predefined roles and permissions, ABAC uses attributes to build policies and make decisions. These attributes can be associated with the user, the action they want to perform, targeted resources, or the environment. With ABAC, finer-grained access control can be achieved, thereby improving the security and efficiency of APIs. This approach is widely used in complex and dynamic environments where access control requirements can be multifaceted and deeply context-dependent.
+
+Learn more from the following resources:
+
+- [@article@What is Attribute Based Access Control?](https://www.okta.com/uk/blog/2020/09/attribute-based-access-control-abac/)
+- [@article@Attribute Based Access Control](https://docs.aws.amazon.com/IAM/latest/UserGuide/introduction_attribute-based-access-control.html)

src/data/roadmaps/api-design/content/basic-auth@0FzHERK5AeYL5wv1FBJbH.md

@@ -1,3 +1,9 @@
 # Basic Auth in API Design
 
-Basic Auth, short for Basic Authentication, is a simple method often used in API design for handling user authentication. In this method, client credentials, consisting of a username and password pair, are passed to the API server in a field in the HTTP header. The server then verifies these credentials before granting access to protected resources. Although Basic Auth is straightforward to implement, it is less secure compared to more advanced methods since it involves transmitting credentials in an encoded, but not encrypted, format. It is often used in cases where simplicity is paramount, or High security levels are not required.
+Basic Auth, short for Basic Authentication, is a simple method often used in API design for handling user authentication. In this method, client credentials, consisting of a username and password pair, are passed to the API server in a field in the HTTP header. The server then verifies these credentials before granting access to protected resources. Although Basic Auth is straightforward to implement, it is less secure compared to more advanced methods since it involves transmitting credentials in an encoded, but not encrypted, format. It is often used in cases where simplicity is paramount, or High security levels are not required.
+
+Learn more from the following resources:
+
+- [@article@Basic Auth Generation Header](https://www.debugbear.com/basic-auth-header-generator)
+- [@article@Basic Authentication - Swagger.io](https://swagger.io/docs/specification/authentication/basic-authentication/)
+- [@article@Basic Authentication - Twillio](https://www.twilio.com/docs/glossary/what-is-basic-authentication)

src/data/roadmaps/api-design/content/basics-of-dns@v4nJYD9yiIEUviLPhVTCD.md

@@ -1,3 +1,9 @@
 # Basics of DNS
 
-When discussing the foundational elements of API Design, the Basics of DNS (Domain Name System) can't be overlooked. DNS plays a fundamental role in the way APIs function, acting as the internet's equivalent of a phone book, it interprets human-friendly hostnames into IP addresses that APIs need for communication. Understanding this complex system is essential as it allows for better comprehension of the navigation and messaging flow in API Design. For API developers, knowledge about DNS can significantly aid in troubleshooting connectivity issues, ensuring secure connections, and optimizing API architecture with more efficient calls.
+When discussing the foundational elements of API Design, the Basics of DNS (Domain Name System) can't be overlooked. DNS plays a fundamental role in the way APIs function, acting as the internet's equivalent of a phone book, it interprets human-friendly hostnames into IP addresses that APIs need for communication. Understanding this complex system is essential as it allows for better comprehension of the navigation and messaging flow in API Design. For API developers, knowledge about DNS can significantly aid in troubleshooting connectivity issues, ensuring secure connections, and optimizing API architecture with more efficient calls.
+
+Learn more from the following resources:
+
+- [@article@What is DNS?](https://www.cloudflare.com/en-gb/learning/dns/what-is-dns/)
+- [@article@Introduction to DNS](https://aws.amazon.com/route53/what-is-dns/)
+- [@video@DNS explained in 100 seconds](https://www.youtube.com/watch?v=UVR9lhUGAyU)

src/data/roadmaps/api-design/content/batch-processing@X68HXAAV-nKo-V4Fu1o72.md

@@ -1,3 +1,8 @@
 # Batch Processing in API Design
 
-Batch Processing refers to the method of handling bulk data requests in API design. Here, multiple API requests are packed and processed as a single group or 'batch'. Instead of making numerous individual API calls, a user can make one batch request with numerous operations. This approach can increase performance and efficiency by reducing the overhead of establishing and closing multiple connections. The concept of 'batch processing' in API design is particularly useful in data-intensive applications or systems where the need for processing high volumes of data is prevalent.
+Batch Processing refers to the method of handling bulk data requests in API design. Here, multiple API requests are packed and processed as a single group or 'batch'. Instead of making numerous individual API calls, a user can make one batch request with numerous operations. This approach can increase performance and efficiency by reducing the overhead of establishing and closing multiple connections. The concept of 'batch processing' in API design is particularly useful in data-intensive applications or systems where the need for processing high volumes of data is prevalent.
+
+Learn more from the following resources:
+
+- [@article@API design guidance: bulk vs batch import](https://tyk.io/blog/api-design-guidance-bulk-and-batch-import/)
+- [@video@Stream vs Batch processing explained with examples](https://www.youtube.com/watch?v=1xgBQTF24mU)

src/data/roadmaps/api-design/content/best-practices@q1yaf-RbHIQsOqfzjn4k4.md

@@ -1,3 +1,8 @@
 # Best Practices in API Design
 
-API design has rapidly emerged as a vital component of software development. When designing an API, it is crucial to follow best practices to ensure optimization, scalability, and efficiency. The best practices in API design revolve around principles such as simplicity, consistency, security, and proper documentation among others. These practices not only smoothens the development process but also makes the API more user-friendly, stable, and easily maintainable. Thus, following the best practices in API design is not an option but rather a must for developers and organizations looking to create APIs that last longer and perform better.
+API design has rapidly emerged as a vital component of software development. When designing an API, it is crucial to follow best practices to ensure optimization, scalability, and efficiency. The best practices in API design revolve around principles such as simplicity, consistency, security, and proper documentation among others. These practices not only smoothens the development process but also makes the API more user-friendly, stable, and easily maintainable. Thus, following the best practices in API design is not an option but rather a must for developers and organizations looking to create APIs that last longer and perform better.
+
+Learn more from the following resources:
+
+- [@article@Best practices for REST API design](https://stackoverflow.blog/2020/03/02/best-practices-for-rest-api-design/)
+- [@article@Best practices in API design](https://swagger.io/resources/articles/best-practices-in-api-design/)

src/data/roadmaps/api-design/content/building-json--restful-apis@awdoiCHz7Yc3kYac_iy-a.md

@@ -1,3 +1,9 @@
 # Building JSON / RESTful APIs
 
-Building JSON/RESTful APIs involves designing and implementing APIs that adhere to the architectural constraints of Representational State Transfer (REST). These APIs use JSON (JavaScript Object Notation) as a format for information interchange, due to its lightweight, easy-to-understand, and universally accepted nature. A well-designed RESTful API, utilizing JSON, is key in developing applications that are scalable, maintainable, and easily integrated with other systems. This design approach enables the resources on a server to be accessed and manipulated using standard HTTP protocols, facilitating communication between different services and systems. Furthermore, it enables client-server interactions to be stateless, meaning each request from a client must contain all the information needed by the server to understand and process the request.
+Building JSON/RESTful APIs involves designing and implementing APIs that adhere to the architectural constraints of Representational State Transfer (REST). These APIs use JSON (JavaScript Object Notation) as a format for information interchange, due to its lightweight, easy-to-understand, and universally accepted nature. A well-designed RESTful API, utilizing JSON, is key in developing applications that are scalable, maintainable, and easily integrated with other systems. This design approach enables the resources on a server to be accessed and manipulated using standard HTTP protocols, facilitating communication between different services and systems. Furthermore, it enables client-server interactions to be stateless, meaning each request from a client must contain all the information needed by the server to understand and process the request.
+
+Learn more from the following resources:
+
+- [@article@A specification for building APIs in JSON](https://jsonapi.org/)
+- [@article@How to make a REST API](https://www.integrate.io/blog/how-to-make-a-rest-api/)
+- [@video@What is a REST API?](https://www.youtube.com/watch?v=lsMQRaeKNDk&t=170s)

src/data/roadmaps/api-design/content/caching-strategies@PrvRCR4HCdGar0vcUbG_a.md

@@ -1,3 +1,9 @@
 # Caching Strategies in API Design
 
-Caching in API design serves as a technique that allows you to store copies of data temporarily in places where you can access it more readily. By obtaining this data from high-speed storage rather than slower storage sources, you can help improve the overall speed and performance of the API. Multiple strategies such as HTTP caching, database caching, application caching, and CDN caching can be implemented, each with its own sets of advantages and considerations. Understanding different caching strategies in the context of API design is crucial for designing efficient, high-performing APIs.
+Caching in API design serves as a technique that allows you to store copies of data temporarily in places where you can access it more readily. By obtaining this data from high-speed storage rather than slower storage sources, you can help improve the overall speed and performance of the API. Multiple strategies such as HTTP caching, database caching, application caching, and CDN caching can be implemented, each with its own sets of advantages and considerations. Understanding different caching strategies in the context of API design is crucial for designing efficient, high-performing APIs.
+
+Learn more from the following resources:
+
+- [@article@Caching Strategies for APIs](https://medium.com/@satyendra.jaiswal/caching-strategies-for-apis-improving-performance-and-reducing-load-1d4bd2df2b44)
+- [@article@Using caching strategies to improve API performance](https://www.lonti.com/blog/using-caching-strategies-to-improve-api-performance)
+- [@video@Cache Systems Every Developer Should Know](https://www.youtube.com/watch?v=dGAgxozNWFE)

src/data/roadmaps/api-design/content/ccpa@a-_iIE7UdoXzD00fD9MxN.md

@@ -1,3 +1,8 @@
 # CCPA under Standards and Compliance in API Design
 
-The California Consumer Privacy Act (CCPA) is a pivotal state statute meant to enhance privacy rights and consumer protection for individuals within California, United States. API Design greatly impacts compliance with CCPA, as improper management and exposure of user data can potentially violate this law. Crucially, designing APIs means considering data privacy, security, and user consent from the very foundation. Programmatically, CCPA compliance may involve structuring APIs to respond to user demands such as data access, data deletion, and opt-out requests. It imposes a significant responsibility on API developers to enforce user control over data and maintain rigorous standards of data protection.
+The California Consumer Privacy Act (CCPA) is a pivotal state statute meant to enhance privacy rights and consumer protection for individuals within California, United States. API Design greatly impacts compliance with CCPA, as improper management and exposure of user data can potentially violate this law. Crucially, designing APIs means considering data privacy, security, and user consent from the very foundation. Programmatically, CCPA compliance may involve structuring APIs to respond to user demands such as data access, data deletion, and opt-out requests. It imposes a significant responsibility on API developers to enforce user control over data and maintain rigorous standards of data protection.
+
+Learn more from the following resources:
+
+- [@official@California Consumer Privacy Act (CCPA)](https://oag.ca.gov/privacy/ccpa)
+- [@article@What is the CCPA?](https://www.cloudflare.com/en-gb/learning/privacy/what-is-the-ccpa/)

src/data/roadmaps/api-design/content/common-vulnerabilities@G70wvcOM1Isrx5ZBvS2xP.md

@@ -1,3 +1,8 @@
 # Common Vulnerabilities in API Design
 
-API design is a critical component of modern software development, enabling various applications to communicate and share data. However, as the use of APIs expands, so does the potential for security vulnerabilities. Understanding common vulnerabilities in API design is crucial to protecting sensitive data and maintaining a secure system. These vulnerabilities might arise due to lack of proper validation, weak authentication mechanisms, insecure endpoint configurations among others. This topic will delve into these common vulnerabilities, focusing on their identification, potential impacts, and how to design APIs with security best practices to mitigate these threats.
+API design is a critical component of modern software development, enabling various applications to communicate and share data. However, as the use of APIs expands, so does the potential for security vulnerabilities. Understanding common vulnerabilities in API design is crucial to protecting sensitive data and maintaining a secure system. These vulnerabilities might arise due to lack of proper validation, weak authentication mechanisms, insecure endpoint configurations among others.
+
+Learn more from the following resources:
+
+- [@article@API Vulnerability Overview](https://apimike.com/api-vulnerabilities)
+- [@article@Top API Vulnerabilities and 6 Ways to Mitigate Them](https://brightsec.com/blog/top-api-vulnerabilities-and-6-ways-to-mitigate-them/)

src/data/roadmaps/api-design/content/content-negotiation@TX_hg7EobNJhmWKsMCaT1.md

@@ -1,3 +1,8 @@
 # Content Negotiation in API Design
 
-In the context of API design, Content Negotiation refers to the process where the client and the server communicate about the data representation which is acceptable for both of them. It allows clients to indicate the preferred response format, such as JSON, XML, or HTML. This mechanism leads to flexible and adaptable APIs, enhancing their usability. Understanding and efficiently utilizing content negotiation is an integral part of mastering API design basics.
+In the context of API design, Content Negotiation refers to the process where the client and the server communicate about the data representation which is acceptable for both of them. It allows clients to indicate the preferred response format, such as JSON, XML, or HTML. This mechanism leads to flexible and adaptable APIs, enhancing their usability. Understanding and efficiently utilizing content negotiation is an integral part of mastering API design basics.
+
+Learn more from the following resources:
+
+- [@article@Content Negotiation](https://developer.mozilla.org/en-US/docs/Web/HTTP/Content_negotiation)
+- [@article@Content Negotiation in practice](https://softwaremill.com/content-negotiation-in-practice/)

src/data/roadmaps/api-design/content/contract-testing@NqeBglhzukVMMEF9p2CXc.md

@@ -1,3 +1,9 @@
 # Contract Testing in API Design
 
-Contract Testing is a critical aspect of maintaining a robust and reliable API infrastructure. In the realm of API design, Contract Testing refers to the method of ensuring that APIs work as anticipated and that changes to them do not break their intended functionality. This approach validates the interaction between two different systems, typically consumer and provider ( API), ensuring they comply with their agreed-upon contract. By defining clear and concise contracts for our APIs, developers can avoid common deployment issues and enhance system integration processes.
+Contract Testing is a critical aspect of maintaining a robust and reliable API infrastructure. In the realm of API design, Contract Testing refers to the method of ensuring that APIs work as anticipated and that changes to them do not break their intended functionality. This approach validates the interaction between two different systems, typically consumer and provider ( API), ensuring they comply with their agreed-upon contract. By defining clear and concise contracts for our APIs, developers can avoid common deployment issues and enhance system integration processes.
+
+Learn more from the following resources:
+
+- [@article@A complete guide to Contract Testing](https://testsigma.com/blog/api-contract-testing/)
+- [@article@Get started with API Contract Testing](https://saucelabs.com/resources/blog/getting-started-with-api-contract-testing)
+- [@article@Contract Testing](https://www.postman.com/templates/42247877-8529-429d-acba-4de20c3b5b3b/Contract-testing/)

src/data/roadmaps/api-design/content/cookies@UFuX8wcxZQ7dvaQF_2Yp8.md

@@ -1,3 +1,8 @@
 # Cookies in API Design
 
-Cookies play an instrumental role in the field of API (Application Programming Interface) design. Essentially, cookies are small bits of data stored on a user's browser that enables stateful HTTP sessions, by storing pertinent information between server communications. In API design, cookies are especially useful when authentication is required. Cookies can store session tokens, thereby allowing users to stay logged in across multiple sessions or different web pages. Understanding cookies and how they function is vital in API design for sustaining user sessions, providing enhanced user experience, and securing user information.
+Cookies play an instrumental role in the field of API (Application Programming Interface) design. Essentially, cookies are small bits of data stored on a user's browser that enables stateful HTTP sessions, by storing pertinent information between server communications. In API design, cookies are especially useful when authentication is required. Cookies can store session tokens, thereby allowing users to stay logged in across multiple sessions or different web pages. Understanding cookies and how they function is vital in API design for sustaining user sessions, providing enhanced user experience, and securing user information.
+
+Learn more from the following resources:
+
+- [@article@What Are API Cookies? How to Send it?](https://apidog.com/articles/what-are-api-cookies/)
+- [@article@Cookes - Mozilla](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/cookies)

src/data/roadmaps/api-design/content/cors@GRlsBogOlOwuqhMMPyHN3.md

@@ -1,3 +1,9 @@
 # CORS under API Design
 
-Cross-Origin Resource Sharing (CORS) is a critical concept in API Design. It is a mechanism that uses HTTP headers to tell browsers to give a web application running at one origin, access to selected resources from a different origin. By default, web browsers prohibit web pages from making requests to a different domain than the one the web page came from. CORS is the guideline that lets you configure a set of rules on the server to define which types of cross-domain requests are allowed, providing much-needed flexibility without compromising security. Understanding CORS is crucial in designing APIs that ensure safe and effective inter-domain communication.
+Cross-Origin Resource Sharing (CORS) is a critical concept in API Design. It is a mechanism that uses HTTP headers to tell browsers to give a web application running at one origin, access to selected resources from a different origin. By default, web browsers prohibit web pages from making requests to a different domain than the one the web page came from. CORS is the guideline that lets you configure a set of rules on the server to define which types of cross-domain requests are allowed, providing much-needed flexibility without compromising security. Understanding CORS is crucial in designing APIs that ensure safe and effective inter-domain communication.
+
+Learn more from the following resources:
+
+- [@article@Cross-Origin Resource Sharing (CORS)](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS)
+- [@article@What is CORS?](https://aws.amazon.com/what-is/cross-origin-resource-sharing/)
+- [@video@CORS in 100 seconds](https://www.youtube.com/watch?v=4KHiSt0oLJ0)

src/data/roadmaps/api-design/content/error-handling--retries@XD1vDtrRQFbLyKJaD1AlA.md

@@ -2,4 +2,9 @@
 
 When creating effective API designs, addressing Error Handling and Retries forms an essential facet. This is primarily due to the fact that APIs aren't always error-free and instances of network hiccups or input inaccuracies from users can occur. Without robust error handling, such occurrences can easily lead to catastrophic application failure or unsatisfactory user experiences. 
 
-In this context, error handling can refer to validating inputs, managing exceptions, and returning appropriate error message or status codes to the user. Meanwhile, the concept of retries comes into play to ensure maximum request success amidst transient failures. Through correctly implemented retries, an API can repeatedly attempt to execute a request until it is successful, thus ensuring seamless operation. The criteria and mechanisms of retries, including the count, delay, and conditions for retries, are crucial aspects to solidify during the API design.
+In this context, error handling can refer to validating inputs, managing exceptions, and returning appropriate error message or status codes to the user. Meanwhile, the concept of retries comes into play to ensure maximum request success amidst transient failures. Through correctly implemented retries, an API can repeatedly attempt to execute a request until it is successful, thus ensuring seamless operation. The criteria and mechanisms of retries, including the count, delay, and conditions for retries, are crucial aspects to solidify during the API design.
+
+Learn more from the following resources:
+
+- [@video@How to make resilient web applications with retries](https://www.youtube.com/watch?v=Gly94hp3Eec)
+- [@article@How To Improve Your Backend By Adding Retries to Your API Calls](https://hackernoon.com/how-to-improve-your-backend-by-adding-retries-to-your-api-calls-83r3udx)

src/data/roadmaps/api-design/content/error-handling@8tELdagrOaGCf3nMVs8t3.md

@@ -1,3 +1,9 @@
 # Error Handling in API Design
 
-Error Handling is a crucial aspect of API design that ensures the stability, usability, and reliability of the API in production. APIs are designed to help systems communicate with each other. However, there can be instances where these systems might encounter exceptions or errors. The process of predicting, catching, and managing these error occurrences is what we refer to as 'Error Handling'. In the context of API Design, it involves defining and implementing specific strategies to detect, manage and inform consumers of any exception or error that occurs while executing requests. Configuring this appropriately provides a more robust and seamless communication experience, enabling developers to debug and rectify issues more efficiently.
+Error Handling is a crucial aspect of API design that ensures the stability, usability, and reliability of the API in production. APIs are designed to help systems communicate with each other. However, there can be instances where these systems might encounter exceptions or errors. The process of predicting, catching, and managing these error occurrences is what we refer to as 'Error Handling'. In the context of API Design, it involves defining and implementing specific strategies to detect, manage and inform consumers of any exception or error that occurs while executing requests. Configuring this appropriately provides a more robust and seamless communication experience, enabling developers to debug and rectify issues more efficiently.
+
+Learn more from the following resources:
+
+- [@article@Best practices for API error handling](https://blog.postman.com/best-practices-for-api-error-handling/)
+- [@article@Best Practices for REST API Error Handling](https://www.baeldung.com/rest-api-error-handling-best-practices)
+- [@video@Handling HTTP API Errors with Problem Details](https://www.youtube.com/watch?v=uvTT_0hqhyY)

src/data/roadmaps/api-design/content/event-driven-architecture@oMfOBkVsgiLvFLicOUdx6.md

@@ -1,3 +1,9 @@
 # Event Driven Architecture in API Design
 
-Event-driven architecture (EDA) is a software design concept that revolves around the production, interpretation, and consumption of events. With regards to API design, EDA grants systems the flexibility to decentralize analytics, microservices, and operations, thus promoting real-time information sharing and reaction. Event-driven APIs prioritize asynchronous communication, allowing applications to stay responsive even when tackling heavy data loads. For an effective API, adhering to EDA provides data reliability, maturity with a scalable structure, and efficient real-time data processing capabilities.
+Event-driven architecture (EDA) is a software design concept that revolves around the production, interpretation, and consumption of events. With regards to API design, EDA grants systems the flexibility to decentralize analytics, microservices, and operations, thus promoting real-time information sharing and reaction. Event-driven APIs prioritize asynchronous communication, allowing applications to stay responsive even when tackling heavy data loads. For an effective API, adhering to EDA provides data reliability, maturity with a scalable structure, and efficient real-time data processing capabilities.
+
+Learn more form the following resources:
+
+- [@article@Event-driven architecture style](https://learn.microsoft.com/en-us/azure/architecture/guide/architecture-styles/event-driven)
+- [@article@Event-driven architecture](https://aws.amazon.com/event-driven-architecture/)
+- [@video@Event-Driven Architecture: Explained in 7 Minutes!](https://www.youtube.com/watch?v=gOuAqRaDdHA)

src/data/roadmaps/api-design/content/functional-testing@6lm3wy9WTAERTqXCn6pFt.md

@@ -1,3 +1,8 @@
 # Functional Testing in API Design
 
-Functional testing in the context of API design involves validating the endpoints and key-value pairs of an API. It ensures the server response works as expected and assesses the functionality of the API -- whether it is performing all the intended functions correctly. Various approaches like testing request-response pairs, error codes, and data accuracy are used. Functional testing can provide invaluable insights into how well an API meets the specified requirements and whether it is ready for integration into applications.
+Functional testing in the context of API design involves validating the endpoints and key-value pairs of an API. It ensures the server response works as expected and assesses the functionality of the API -- whether it is performing all the intended functions correctly. Various approaches like testing request-response pairs, error codes, and data accuracy are used. Functional testing can provide invaluable insights into how well an API meets the specified requirements and whether it is ready for integration into applications.
+
+Learn more from the following resources:
+
+- [@article@API Functional Testing – Why Is It Important And How to Test](https://testsigma.com/blog/api-functional-testing/)
+- [@video@What Is API Functional Testing?](https://www.youtube.com/watch?v=CvJHDKMWofk)

src/data/roadmaps/api-design/content/gdpr@vZxdswGLHCPi5GSuXEcHJ.md

@@ -1,3 +1,8 @@
 # GDPR in API Design
 
-The General Data Protection Regulation (GDPR) is an essential standard in API Design that addresses the storage, transfer, and processing of personal data of individuals within the European Union. With regards to API Design, considerations must be given on how APIs handle, process, and secure the data to conform with GDPR's demands on data privacy and security. This includes requirements for explicit consent, right to erasure, data portability, and privacy by design. Non-compliance with these standards not only leads to hefty fines but may also erode trust from users and clients. As such, understanding the impact and integration of GDPR within API design is pivotal for organizations handling EU residents' data.
+The General Data Protection Regulation (GDPR) is an essential standard in API Design that addresses the storage, transfer, and processing of personal data of individuals within the European Union. With regards to API Design, considerations must be given on how APIs handle, process, and secure the data to conform with GDPR's demands on data privacy and security. This includes requirements for explicit consent, right to erasure, data portability, and privacy by design. Non-compliance with these standards not only leads to hefty fines but may also erode trust from users and clients. As such, understanding the impact and integration of GDPR within API design is pivotal for organizations handling EU residents' data.
+
+Learn more from the following resources:
+
+- [@official@GDPR](https://gdpr-info.eu/)
+- [@article@What is GDPR Compliance in Web Application and API Security?](https://probely.com/blog/what-is-gdpr-compliance-in-web-application-and-api-security/)

src/data/roadmaps/api-design/content/graphql-apis@MKVcPM2EzAr2_Ieyp9Fu3.md

@@ -1,3 +1,9 @@
 # GraphQL APIs
 
-GraphQL is an open-source data query and manipulation language for APIs, and a runtime for executing those queries with your existing data. Unlike REST, where you have predefined data return structures for each endpoint, GraphQL APIs are designed around a type system and enable the client application to precisely specify what data it needs from the server. This gives a lot of flexibility and efficiency, leading to fewer round trips to the server and significantly enhancing the performance of the client application. Whether you are building a small project or an enterprise-scale application, understanding and implementing GraphQL APIs can result in cleaner, more manageable code.
+GraphQL is an open-source data query and manipulation language for APIs, and a runtime for executing those queries with your existing data. Unlike REST, where you have predefined data return structures for each endpoint, GraphQL APIs are designed around a type system and enable the client application to precisely specify what data it needs from the server. This gives a lot of flexibility and efficiency, leading to fewer round trips to the server and significantly enhancing the performance of the client application. Whether you are building a small project or an enterprise-scale application, understanding and implementing GraphQL APIs can result in cleaner, more manageable code.
+
+Learn more from the following resources:
+
+- [@official@GraphQL Website](https://graphql.org/)
+- [@opensource@Public GraphQL APIs](https://github.com/graphql-kit/graphql-apis)
+- [@video@GraphQL explained in 100 seconds](https://www.youtube.com/watch?v=eIQh02xuVw4)

src/data/roadmaps/api-design/content/handling-crud-operations@zXxEiM5HeOn7W-Vue0tQf.md

@@ -2,4 +2,10 @@
 
 When designing APIs, one needs to account for various types of interactions with data - these typically revolve around the CRUD operations; Create, Read, Update, and Delete. Whether the API is designed for a banking app or a social media platform, the need to create new data, read or retrieve existing data, update or modify that data, and delete unnecessary data is universal.
 
-Therefore, mastering CRUD operations in API design is a fundamental skill. Effective handling of CRUD operations facilitates seamless interaction between the front-end and back-end systems, and ensures proper data management, thereby improving user experience.
+Therefore, mastering CRUD operations in API design is a fundamental skill. Effective handling of CRUD operations facilitates seamless interaction between the front-end and back-end systems, and ensures proper data management, thereby improving user experience.
+
+Learn more from the following resources:
+
+- [@article@Introduction to Building a CRUD API with Node.js and Express](https://www.split.io/blog/introduction-to-building-a-crud-api-with-node-js-and-express/)
+- [@article@An expert's guide to CRUD APIs](https://www.forestadmin.com/blog/an-experts-guide-to-crud-apis-designing-a-robust-one/)
+- [@article@Rethinking CRUD For REST API Designs - Palentir](https://blog.palantir.com/rethinking-crud-for-rest-api-designs-a2a8287dc2af)

src/data/roadmaps/api-design/content/hateoas@LByD1vhzunhY1uY1YGZHP.md

@@ -1,3 +1,9 @@
 # HATEOAS in API Design
 
-Hypertext As The Engine Of Application State (HATEOAS) is a key concept in the design of RESTful APIs (Application Programming Interfaces). It implies that the API delivers data as well as information about available interactions. By utilizing hypermedia, it contributes to the self-descriptiveness and discoverability of the API. When correctly implemented, clients only need generic knowledge about hypermedia, not specific API semantics, which can significantly simplify client implementations and make APIs more flexible to changes. The principle of HATEOAS can enforce a more structured, standardized approach to API design and development.
+Hypertext As The Engine Of Application State (HATEOAS) is a key concept in the design of RESTful APIs (Application Programming Interfaces). It implies that the API delivers data as well as information about available interactions. By utilizing hypermedia, it contributes to the self-descriptiveness and discoverability of the API. When correctly implemented, clients only need generic knowledge about hypermedia, not specific API semantics, which can significantly simplify client implementations and make APIs more flexible to changes. The principle of HATEOAS can enforce a more structured, standardized approach to API design and development.
+
+Learn more from the following resources:
+
+- [@article@HATEOAS Driven REST APIs](https://restfulapi.net/hateoas/)
+- [@article@HATEOAS](https://htmx.org/essays/hateoas/)
+- [@video@What Happend To HATEOAS in RESTful API?](https://www.youtube.com/watch?v=HNTSrytKCoQ)

src/data/roadmaps/api-design/content/hipaa@W4WwTmgZGnWmiYsB0ezml.md

@@ -1,3 +1,8 @@
 # HIPAA in API Design
 
-HIPAA (Health Insurance Portability and Accountability Act) is a critical standard when it comes to API design in the healthcare industry. In essence, it provides the mandate for protecting sensitive patient data. Any organization dealing with protected health information (PHI) must ensure all required physical, network, and process security measures are in place. In the context of API design, HIPAA compliance means structuring endpoints, data transmission, and storage methods that align with these crucial safeguards. This encompasses encryption, access controls, audit controls, and integrity controls. Hence, understanding HIPAA is fundamental for API designers working in the healthcare domain.
+HIPAA (Health Insurance Portability and Accountability Act) is a critical standard when it comes to API design in the healthcare industry. In essence, it provides the mandate for protecting sensitive patient data. Any organization dealing with protected health information (PHI) must ensure all required physical, network, and process security measures are in place. In the context of API design, HIPAA compliance means structuring endpoints, data transmission, and storage methods that align with these crucial safeguards. This encompasses encryption, access controls, audit controls, and integrity controls. Hence, understanding HIPAA is fundamental for API designers working in the healthcare domain.
+
+Learn more from the following resources:
+
+- [@official@HIPAA](https://www.hhs.gov/hipaa/index.html)
+- [@video@The 11 MOST Common HIPAA Violations](https://www.youtube.com/watch?v=sN-zLAqYoTo)

src/data/roadmaps/api-design/content/http-caching@qAolZHf_jp8hCdtqHZwC8.md

@@ -1,3 +1,8 @@
 # HTTP Caching in API Design
 
-HTTP caching is a key aspect of API design which involves storing copies of responses to HTTP requests to speed up future requests. When an API receives the same request multiple times, instead of processing each request separately, it can use a previously stored response, thereby improving performance and efficiency. The cache is governed by headers on the HTTP requests and responses. Understanding and implementing HTTP caching in API design can drastically reduce latency, network traffic and improve the speed of an API.
+HTTP caching is a key aspect of API design which involves storing copies of responses to HTTP requests to speed up future requests. When an API receives the same request multiple times, instead of processing each request separately, it can use a previously stored response, thereby improving performance and efficiency. The cache is governed by headers on the HTTP requests and responses. Understanding and implementing HTTP caching in API design can drastically reduce latency, network traffic and improve the speed of an API.
+
+Learn more from the following resources:
+
+- [@article@Why HTTP Caching matters for APIs](https://thenewstack.io/why-http-caching-matters-for-apis/)
+- [@article@Caching REST API Response](https://restfulapi.net/caching/)

src/data/roadmaps/api-design/content/http-headers@rE-0yibRH6B2UBKp351cf.md

@@ -1,3 +1,9 @@
 # HTTP Headers in API Design
 
-HTTP Headers play a crucial role in API Design as they provide essential information between the client and server regarding the data to be exchanged. Headers are part of the HTTP request and response message, with types including Standard, Non-standard, Common or Uncommon headers. They can define parameters such as content type, authentication, response status, cookies, and more. Understanding and effectively utilizing HTTP Headers is key to designing robust and secure APIs. A well-defined set of headers ensures successful data exchange, handles errors gracefully, and improves overall communication between the client and server.
+HTTP Headers play a crucial role in API Design as they provide essential information between the client and server regarding the data to be exchanged. Headers are part of the HTTP request and response message, with types including Standard, Non-standard, Common or Uncommon headers. They can define parameters such as content type, authentication, response status, cookies, and more. Understanding and effectively utilizing HTTP Headers is key to designing robust and secure APIs. A well-defined set of headers ensures successful data exchange, handles errors gracefully, and improves overall communication between the client and server.
+
+Learn more from the following resources:
+
+- [@article@HTTP Headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers)
+- [@article@What are HTTP headers?](https://blog.postman.com/what-are-http-headers/)
+- [@article@What are HTTP Headers & Understand different types of HTTP headers](https://requestly.com/blog/what-are-http-headers-understand-different-types-of-http-headers/)

src/data/roadmaps/api-design/content/http-methods@rADHM-6NAxEjzmgiHefDX.md

@@ -1,3 +1,9 @@
 # HTTP Methods
 
-HTTP (Hypertext Transfer Protocol) Methods play a significant role in API design. They define the type of request a client can make to a server, providing the framework for interaction between client and server. Understanding HTTP methods is paramount to creating a robust and effective API. Some of the common HTTP methods used in API design include GET, POST, PUT, DELETE, and PATCH. Each of these methods signifies a different type of request, allowing for various interactions with your API endpoints. This in turn creates a more dynamic, functional, and user-friendly API.
+HTTP (Hypertext Transfer Protocol) Methods play a significant role in API design. They define the type of request a client can make to a server, providing the framework for interaction between client and server. Understanding HTTP methods is paramount to creating a robust and effective API. Some of the common HTTP methods used in API design include GET, POST, PUT, DELETE, and PATCH. Each of these methods signifies a different type of request, allowing for various interactions with your API endpoints. This in turn creates a more dynamic, functional, and user-friendly API.
+
+Learn more from the following resources:
+
+- [@article@HTTP request methods](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods)
+- [@article@HTTP Request Methods - W3Schools](https://www.w3schools.com/tags/ref_httpmethods.asp)
+- [@article@What are HTTP Methods?](https://blog.postman.com/what-are-http-methods/)

src/data/roadmaps/api-design/content/http-status-codes@7szYyzLifKsepNU0c2KnN.md

@@ -1,3 +1,10 @@
 # HTTP Status Codes
 
-HTTP Status Codes are an essential part of API Design, providing important information about the result of a request made to a server. They are 3-digit numbers where the first digit defines the class of response, while the last two digits do not have any categorization value. For instance, '200' stands for a successful HTTP request, while '404' signifies that a requested resource could not be found on the server. Efficient use of these codes can enhance API's robustness, making it more understandable and easier to debug.
+HTTP Status Codes are an essential part of API Design, providing important information about the result of a request made to a server. They are 3-digit numbers where the first digit defines the class of response, while the last two digits do not have any categorization value. For instance, '200' stands for a successful HTTP request, while '404' signifies that a requested resource could not be found on the server. Efficient use of these codes can enhance API's robustness, making it more understandable and easier to debug.
+
+Learn more from the following resources:
+
+- [@article@HTTP Status Codes](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status)
+- [@articles@What are HTTP status codes?](https://umbraco.com/knowledge-base/http-status-codes/)
+- [@article@List of HTTP status codes](https://en.wikipedia.org/wiki/List_of_HTTP_status_codes)
+- [@video@HTTP Status Codes explained in 5 minutes](https://www.youtube.com/watch?v=qmpUfWN7hh4)

src/data/roadmaps/api-design/content/idempotency@20KEgZH6cu_UokqWpV-9I.md

@@ -1,3 +1,8 @@
 # Idempotency in API Design
 
-Idempotency in API design refers to the concept where multiple identical requests have the same effect as a single request. This means that no matter how many times a client sends the same request to the server, the server's state stays the same after the first request. Designing APIs to be idempotent is essential for reliability, as it allows retries without side-effects, reduces complexity in distributed systems, and provides better user experience in unstable network conditions. Understanding idempotency concepts can increase the robustness and fault tolerance of your APIs. It is usually applicable to `PUT`, `DELETE`, and sometimes `POST` methods in RESTful APIs.
+Idempotency in API design refers to the concept where multiple identical requests have the same effect as a single request. This means that no matter how many times a client sends the same request to the server, the server's state stays the same after the first request. Designing APIs to be idempotent is essential for reliability, as it allows retries without side-effects, reduces complexity in distributed systems, and provides better user experience in unstable network conditions. Understanding idempotency concepts can increase the robustness and fault tolerance of your APIs. It is usually applicable to `PUT`, `DELETE`, and sometimes `POST` methods in RESTful APIs.
+
+Learn more from the following resources:
+
+- [@article@What is idempotency?](https://blog.dreamfactory.com/what-is-idempotency)
+- [@article@Idempotent REST API](https://restfulapi.net/idempotent-rest-apis/)

src/data/roadmaps/api-design/content/integration-testing@qZELS5vw2feS7QfyD7spX.md

@@ -1,3 +1,8 @@
 # Integration Testing in API Design
 
-Integration testing is a critical aspect of API design. It is a level of software testing where individual units or components are combined and tested as a group. The main purpose of integration testing in API design is to expose faults and discrepancies in the interaction between integrated units. This testing approach ensures that the different parts of an API work together seamlessly, to deliver the necessary functionality and performance. It helps detect issues related to the network, database, and performance, which unit tests cannot uncover. Thus, this level of testing is instrumental in validating the reliability, efficiency, and functionality of an API's integrated components.
+Integration testing is a critical aspect of API design. It is a level of software testing where individual units or components are combined and tested as a group. The main purpose of integration testing in API design is to expose faults and discrepancies in the interaction between integrated units. This testing approach ensures that the different parts of an API work together seamlessly, to deliver the necessary functionality and performance. It helps detect issues related to the network, database, and performance, which unit tests cannot uncover. Thus, this level of testing is instrumental in validating the reliability, efficiency, and functionality of an API's integrated components.
+
+Learn more from the following resources:
+
+- [@article@How to run API integration tests](https://www.merge.dev/blog/api-integration-testing)
+- [@article@Integration testing template](https://www.postman.com/templates/fe506090-ca91-4340-bea9-82d2c3d2bb9a/Integration-testing/)

src/data/roadmaps/api-design/content/jwt@tWg68AHLIr1gIZA1za3jp.md

@@ -1,3 +1,9 @@
 # JSON Web Token (JWT) in API Design 
 
-JSON Web Tokens, or JWT, are a popular and secure method of transferring information between two parties in the domain of API design. As a compact, URL-safe means of representing claims to be transferred between two parties, they play a vital role in security and authorization in modern APIs. By encoding these claims, the information can be verified and trusted with a digital signature - ensuring that the API end-points can handle requests in a secure and reliable way. JWT is a relatively lightweight and scalable method that brings improved authentication and information exchange processes in API design.
+JSON Web Tokens, or JWT, are a popular and secure method of transferring information between two parties in the domain of API design. As a compact, URL-safe means of representing claims to be transferred between two parties, they play a vital role in security and authorization in modern APIs. By encoding these claims, the information can be verified and trusted with a digital signature - ensuring that the API end-points can handle requests in a secure and reliable way. JWT is a relatively lightweight and scalable method that brings improved authentication and information exchange processes in API design.
+
+Learn more from the following resources:
+
+- [@official@Introduction to JSON Web Tokens](https://jwt.io/introduction)
+- [@article@JSON Web Tokens](https://auth0.com/docs/secure/tokens/json-web-tokens)
+- [@video@Why is JWT popular?](https://www.youtube.com/watch?v=P2CPd9ynFLg)

src/data/roadmaps/api-design/content/kafka@boYX1QcJullypfX4sevdy.md

@@ -1,3 +1,9 @@
 # Kafka in API Design
 
-Apache Kafka is a real-time, fault-tolerant, and highly reliable messaging system that's integral to API design. It's primarily used to build real-time data streaming applications and microservices due to its inherent ability to handle high volume data and multi-subscriber support. In the context of API design, Kafka provides a robust messaging queue system that enables cloud-based platforms and services to communicate seamlessly with each other in a real-time environment. Moreover, the API designers use Kafka APIs such as Producer API, Consumer API, Streams API, and Connect API which enable the transmission and manipulation of messages within the Kafka ecosystem.
+Apache Kafka is a real-time, fault-tolerant, and highly reliable messaging system that's integral to API design. It's primarily used to build real-time data streaming applications and microservices due to its inherent ability to handle high volume data and multi-subscriber support. In the context of API design, Kafka provides a robust messaging queue system that enables cloud-based platforms and services to communicate seamlessly with each other in a real-time environment. Moreover, the API designers use Kafka APIs such as Producer API, Consumer API, Streams API, and Connect API which enable the transmission and manipulation of messages within the Kafka ecosystem.
+
+Learn more from the following resources:
+
+- [@official@Kafka Website](https://kafka.apache.org/)
+- [@opensource@apache/kafka](https://github.com/apache/kafka)
+- [@video@Kafka in 100 seconds](https://www.youtube.com/watch?v=uvb00oaa3k8)

src/data/roadmaps/api-design/content/load-balancing@p5wsniYnOS7cbHd92RxGk.md

@@ -1,3 +1,9 @@
 # Load Balancing in API Design
 
-Load Balancing plays a crucial role in the domain of API Design. It primarily revolves around evenly and efficiently distributing network traffic across a group of backend servers, also known as a server farm or server pool. When it comes to API design, implementing load balancing algorithms is of immense importance to ensure that no single server bears too much demand. This allows for high availability and reliability by rerouting the traffic in case of server failure, effectively enhancing application performance and contributing to a positive user experience. Therefore, it's a vital tactic in ensuring the scalability and robustness of system architectures which heavily rely on API interactions.
+Load Balancing plays a crucial role in the domain of API Design. It primarily revolves around evenly and efficiently distributing network traffic across a group of backend servers, also known as a server farm or server pool. When it comes to API design, implementing load balancing algorithms is of immense importance to ensure that no single server bears too much demand. This allows for high availability and reliability by rerouting the traffic in case of server failure, effectively enhancing application performance and contributing to a positive user experience. Therefore, it's a vital tactic in ensuring the scalability and robustness of system architectures which heavily rely on API interactions.
+
+Learn more from the following resources:
+
+- [@article@What is load balancing?](https://www.cloudflare.com/en-gb/learning/performance/what-is-load-balancing/)
+- [@article@API Gateway vs Load Balancer: Which is Right for Your Application?](https://konghq.com/blog/engineering/api-gateway-vs-load-balancer)
+- [@video@What is a load balancer?](https://www.youtube.com/watch?v=sCR3SAVdyCc)

src/data/roadmaps/api-design/content/load-testing@7JNEx_cbqnAx3esvwZMOd.md

@@ -1,3 +1,9 @@
 # Load Testing in API Design
 
-Load testing is a crucial aspect of API design that ensures reliability, efficiency and performance under varying loads. It primarily focuses on identifying the maximum capacity of the API in terms of the volume of requests it can handle and its subsequent behavior when this threshold is reached or overloaded. By simulating varying degrees of user load, developers can identify and rectify bottlenecks or breakdown points in the system, hence enhancing overall API resilience.
+Load testing is a crucial aspect of API design that ensures reliability, efficiency and performance under varying loads. It primarily focuses on identifying the maximum capacity of the API in terms of the volume of requests it can handle and its subsequent behavior when this threshold is reached or overloaded. By simulating varying degrees of user load, developers can identify and rectify bottlenecks or breakdown points in the system, hence enhancing overall API resilience.
+
+Learn more from the following resources:
+
+- [@article@API load testing - a beginners guide](https://grafana.com/blog/2024/01/30/api-load-testing/)
+- [@article@Test your API’s performance by simulating real-world traffic](https://blog.postman.com/postman-api-performance-testing/)
+- [@video@Load testing your API's](https://www.youtube.com/watch?v=a5hWE4hMOoY)

src/data/roadmaps/api-design/content/messaging-queues@IkPZel5zxXWIx90Qx7fZI.md

@@ -1,3 +1,8 @@
 # Messaging Queues in API Design
 
-Messaging Queues play a fundamental role in API design, particularly in creating robust, decoupled, and efficient systems. These queues act like a buffer, storing messages or data sent from a sender (producer), allowing a receiver (consumer) to retrieve and process them at its own pace. In the context of API design, this concept enables developers to handle high-volume data processing requirements, providing an asynchronous communication protocol between multiple services. The benefits of messaging queues in API design include better system scalability, fault tolerance, and increased overall system resiliency.
+Messaging Queues play a fundamental role in API design, particularly in creating robust, decoupled, and efficient systems. These queues act like a buffer, storing messages or data sent from a sender (producer), allowing a receiver (consumer) to retrieve and process them at its own pace. In the context of API design, this concept enables developers to handle high-volume data processing requirements, providing an asynchronous communication protocol between multiple services. The benefits of messaging queues in API design include better system scalability, fault tolerance, and increased overall system resiliency.
+
+Learn more from the following resources:
+
+- [@article@What is a message queue?](https://aws.amazon.com/message-queue/)
+- [@video@REST API message queues explained](https://www.youtube.com/watch?v=2idPgA6IN_Q)

src/data/roadmaps/api-design/content/microservices-architecture@PPeBbooE121zrgNwpVTiA.md

@@ -1,3 +1,9 @@
 # Microservices Architecture
 
-When it comes to API Design, Microservices Architecture plays a crucial role. It represents a unique method of developing software systems that focuses on building single-function modules with well-defined interfaces. Each microservice runs a unique process and communicates through a well-defined, lightweight mechanism (often HTTP resources API) to serve a specific business goal. This architecture allows rapid, reliable, and scalable deployment of large, complex applications. It facilitates the organization of the development team around independently deployable units, thereby enhancing productivity and speed. When designing an API, it's essential to adapt this model to get a flexible and scalable construction.
+When it comes to API Design, Microservices Architecture plays a crucial role. It represents a unique method of developing software systems that focuses on building single-function modules with well-defined interfaces. Each microservice runs a unique process and communicates through a well-defined, lightweight mechanism (often HTTP resources API) to serve a specific business goal. This architecture allows rapid, reliable, and scalable deployment of large, complex applications. It facilitates the organization of the development team around independently deployable units, thereby enhancing productivity and speed. When designing an API, it's essential to adapt this model to get a flexible and scalable construction.
+
+Learn more from the following resources:
+
+- [@video@Microservices explained in 5 minutes](https://www.youtube.com/watch?v=lL_j7ilk7rc)
+- [@article@What is Microservices Architecture?](https://cloud.google.com/learn/what-is-microservices-architecture)
+- [@article@Microservice Architecture Style](https://learn.microsoft.com/en-us/azure/architecture/guide/architecture-styles/microservices)

src/data/roadmaps/api-design/content/mocking-apis@bEVCT5QGY3uw0kIfAELKh.md

@@ -1,3 +1,9 @@
 # Mocking APIs under API Testing
 
-API mocking is a crucial aspect of API design and testing. It involves simulating the behaviors of real APIs to test various aspects of the system without the need of the real API being readily available. During the stages of development and testing, the API might be undefined or changes in the API can be expected, hence mocking comes into the picture. In such cases, it helps software developers and testers to isolate the system and work independently, enhancing the control over the input and output of the test. The focus here ranges from testing the API for functionality, reliability, performance, to security. Therefore, understanding and implementing effective API mocking strategies can significantly streamline the API design and development process.
+API mocking is a crucial aspect of API design and testing. It involves simulating the behaviors of real APIs to test various aspects of the system without the need of the real API being readily available. During the stages of development and testing, the API might be undefined or changes in the API can be expected, hence mocking comes into the picture. In such cases, it helps software developers and testers to isolate the system and work independently, enhancing the control over the input and output of the test. The focus here ranges from testing the API for functionality, reliability, performance, to security. Therefore, understanding and implementing effective API mocking strategies can significantly streamline the API design and development process.
+
+Learn more from the following resources:
+
+- [@article@What is API Mocking? Definition, Guide, and Best Practices](https://katalon.com/resources-center/blog/what-is-api-mocking)
+- [@articleWhat is API mocking (What is API Mocking? Definition, Guide, and Best Practices)](https://blog.postman.com/what-is-api-mocking/)
+- [@video@How to Mock RESTFUL APIs - The Easy way!](https://www.youtube.com/watch?v=tJRN5WBF5Wc)

src/data/roadmaps/api-design/content/oauth-20@TLuNtQ6HKYQXmglyVk8-t.md

@@ -1,3 +1,9 @@
 # OAuth 2.0
 
-OAuth 2.0 is an authorization framework that allows applications to obtain limited access to user accounts on an HTTP service, such as Facebook, GitHub, DigitalOcean, and others. It works by delegating user authentication to the service that hosts the user account and authorizing third-party applications to access the user account. OAuth 2.0 defines four roles: resource owner, client, resource server and authorization server. With regards to API design, OAuth 2.0 can be used to protect API endpoints by ensuring that the client applications having valid access tokens can only interact with the API. It provides detailed workflow processes and a set of protocols for the client application to get authorization to access resources.
+OAuth 2.0 is an authorization framework that allows applications to obtain limited access to user accounts on an HTTP service, such as Facebook, GitHub, DigitalOcean, and others. It works by delegating user authentication to the service that hosts the user account and authorizing third-party applications to access the user account. OAuth 2.0 defines four roles: resource owner, client, resource server and authorization server. With regards to API design, OAuth 2.0 can be used to protect API endpoints by ensuring that the client applications having valid access tokens can only interact with the API. It provides detailed workflow processes and a set of protocols for the client application to get authorization to access resources.
+
+Learn more from the following resources:
+
+- [@official@OAuth Website](https://oauth.net/2/)
+- [@article@What is OAuth 2.0?](https://auth0.com/intro-to-iam/what-is-oauth-2)
+- [@video@OAuth 2 Explained In Simple Terms](https://www.youtube.com/watch?v=ZV5yTm4pT8g)

src/data/roadmaps/api-design/content/pagination@pgJDzP3pJjhjr5wTRtPJO.md

@@ -1,3 +1,9 @@
 # Pagination in API Design
 
-Pagination is a crucial aspect of API design, providing a systematic approach to handling large amounts of data in a manageable way. Instead of returning all data in a single response, which can be overwhelming and inefficient, APIs implement pagination to deliver this data in smaller, more convenient parcels. This allows client applications to fetch data incremently and only as needed, greatly enhancing performance and usability. The design and implementation of pagination can vary, with different strategies such as limit-offset, cursor-based, or time-based pagination, each with its own set of advantages and limitations. An effective API design should carefully consider pagination style, striving for a balance between ease of use, efficiency, and scalability.
+Pagination is a crucial aspect of API design, providing a systematic approach to handling large amounts of data in a manageable way. Instead of returning all data in a single response, which can be overwhelming and inefficient, APIs implement pagination to deliver this data in smaller, more convenient parcels. This allows client applications to fetch data incremently and only as needed, greatly enhancing performance and usability. The design and implementation of pagination can vary, with different strategies such as limit-offset, cursor-based, or time-based pagination, each with its own set of advantages and limitations. An effective API design should carefully consider pagination style, striving for a balance between ease of use, efficiency, and scalability.
+
+Learn more from the following resources:
+
+- [@article@Everything you need to know about API pagination](https://nordicapis.com/everything-you-need-to-know-about-api-pagination/)
+- [@article@Pagination in the REST API - Atlassian](https://developer.atlassian.com/server/confluence/pagination-in-the-rest-api/)
+- [@article@Unlock the power of API pagination](https://dev.to/pragativerma18/unlocking-the-power-of-api-pagination-best-practices-and-strategies-4b49)

src/data/roadmaps/api-design/content/pci-dss@J0enF8UTVzY3H4n3pbPIF.md

@@ -1,3 +1,8 @@
 # PCI DSS in API Design
 
-Payment Card Industry Data Security Standard (PCI DSS) is a widely accepted set of policies and procedures intended to optimize the security of credit, debit and cash card transactions and protect cardholders against misuse of their personal information. In terms of API Design, building APIs in compliance with PCI DSS is crucial when processing, storing or transmitting credit card information. By adhering to these standards, not only can developers ensure safe and secure API endpoints but also build trust among users by safeguarding their sensitive financial data.
+Payment Card Industry Data Security Standard (PCI DSS) is a widely accepted set of policies and procedures intended to optimize the security of credit, debit and cash card transactions and protect cardholders against misuse of their personal information. In terms of API Design, building APIs in compliance with PCI DSS is crucial when processing, storing or transmitting credit card information. By adhering to these standards, not only can developers ensure safe and secure API endpoints but also build trust among users by safeguarding their sensitive financial data.
+
+Learn more from the following resources:
+
+- [@article@What is PCI DSS and how to comply?](https://www.itgovernance.co.uk/pci_dss)
+- [@article@Payment Card Industry Data Security Standard](https://en.wikipedia.org/wiki/Payment_Card_Industry_Data_Security_Standard)

src/data/roadmaps/api-design/content/performance-metrics@nQpczZUcn-TvrfT80dv0Q.md

@@ -1,3 +1,8 @@
 # Performance Metrics in API Design
 
-API Design performance metrics play a critical role in ensuring APIs are efficient, effective, and absolutely fit for their intended purpose. The performance of an API can profoundly impact the user experience and overall system performance. Therefore, it is crucial to define and monitor a set of performance metrics. These may include response times, throughput, error rates, and others that measure system health and resource utilization. By prioritizing these metrics in the context of API Design, developers can create APIs that not only meet functional requirements but also deliver desired performance levels.
+API Design performance metrics play a critical role in ensuring APIs are efficient, effective, and absolutely fit for their intended purpose. The performance of an API can profoundly impact the user experience and overall system performance. Therefore, it is crucial to define and monitor a set of performance metrics. These may include response times, throughput, error rates, and others that measure system health and resource utilization. By prioritizing these metrics in the context of API Design, developers can create APIs that not only meet functional requirements but also deliver desired performance levels.
+
+Learn more from the following resources:
+
+- [@article@API Performance Monitoring](https://www.catchpoint.com/api-monitoring-tools/api-performance-monitoring)
+- [@article@How does API monitoring improve API performance?](https://tyk.io/blog/api-product-metrics-what-you-need-to-know/)

src/data/roadmaps/api-design/content/performance-testing@DQcAV59vr1-ZRnMfbLXpu.md

@@ -1,3 +1,8 @@
 # Performance Testing in API Design
 
-Performance Testing in API design refers to the practice of evaluating and ensuring that an API operates reliably and efficiently under varying workloads. Properly conducted performance testing can verify an API's speed, response time, reliability, and scalability. As an integral aspect of API design, it checks if API's are effectively meeting expectations for system functionality and demonstrates the potential areas of optimization. Performance testing is essential in maintaining high standards of user experience by preventing unexpected failures, and optimizing API consumer satisfaction.
+Performance Testing in API design refers to the practice of evaluating and ensuring that an API operates reliably and efficiently under varying workloads. Properly conducted performance testing can verify an API's speed, response time, reliability, and scalability. As an integral aspect of API design, it checks if API's are effectively meeting expectations for system functionality and demonstrates the potential areas of optimization. Performance testing is essential in maintaining high standards of user experience by preventing unexpected failures, and optimizing API consumer satisfaction.
+
+Learn more from the following resources:
+
+- [@article@API Performance Testing: A Step-by-Step Guide](https://testsigma.com/blog/api-performance-testing/)
+- [@article@Simulate user traffic to test your API performance](https://learning.postman.com/docs/collections/performance-testing/testing-api-performance/)

src/data/roadmaps/api-design/content/pii@mXCKtLUvwVJkHrpHzOecq.md

@@ -1,3 +1,8 @@
 # PII under Standards and Compliance
 
-Personal Identifiable Information (PII) under Standards and Compliance is a crucial aspect of API Design. It refers to the secure handling and transmission of personal data such as names, addresses, and credit card numbers, which APIs often deal with. In this context, APIs must be built under strict compliance with standards such as GDPR, HIPAA or PCI DSS, which regulate the protection of personal data. These standards ensure that personal data is not misused and that user privacy is respected. Any violations can lead to hefty fines and damage to the company's reputation. Understanding PII and designing APIs in accordance with applicable regulations is vital for a robust, secure, and compliant API design.
+Personal Identifiable Information (PII) under Standards and Compliance is a crucial aspect of API Design. It refers to the secure handling and transmission of personal data such as names, addresses, and credit card numbers, which APIs often deal with. In this context, APIs must be built under strict compliance with standards such as GDPR, HIPAA or PCI DSS, which regulate the protection of personal data. These standards ensure that personal data is not misused and that user privacy is respected. Any violations can lead to hefty fines and damage to the company's reputation. Understanding PII and designing APIs in accordance with applicable regulations is vital for a robust, secure, and compliant API design.
+
+Learn more from the following resources:
+
+- [@articles@Personally Identifiable Information (PII): Definition, Types, and Examples](https://www.investopedia.com/terms/p/personally-identifiable-information-pii.asp)
+- [@article@What is Personally Identifiable Information?](https://www.ibm.com/topics/pii)

src/data/roadmaps/api-design/content/postman@KQAus72RGqx5f-3-YeJby.md

@@ -1,3 +1,8 @@
 # Postman in API Design
 
-Postman is a popular tool in web development for designing, testing, and managing APIs. As a collaborative platform, it simplifies each step of the API lifecycle and streamlines collaboration across teams. In context of API design, it can be employed to design and mock APIs, automate testing, and observe responses in a user-friendly interface. API endpoints can be organized into collections also in Postman for a well-structured and organized API design process. Ultimately, its user-friendly interface and comprehensive features position Postman as an indispensable tool in the realm of API design.
+Postman is a popular tool in web development for designing, testing, and managing APIs. As a collaborative platform, it simplifies each step of the API lifecycle and streamlines collaboration across teams. In context of API design, it can be employed to design and mock APIs, automate testing, and observe responses in a user-friendly interface. API endpoints can be organized into collections also in Postman for a well-structured and organized API design process. Ultimately, its user-friendly interface and comprehensive features position Postman as an indispensable tool in the realm of API design.
+
+Learn more from the following resources:
+
+- [@official@Postman Website](https://www.postman.com/)
+- [@video@Postman Api Testing Tutorial for beginners](https://www.youtube.com/watch?v=MFxk5BZulVU)

src/data/roadmaps/api-design/content/profiling-and-monitoring@-qdwBg7HvwlbLy3IKCRij.md

@@ -1,3 +1,8 @@
 # Profiling and Monitoring in API Design 
 
-Profiling and monitoring are critical aspects of API design and implementation. Profiling, in this context, refers to the process of analyzing the behavior of your API in order to understand various performance metrics including response times, request rates, error rates, and the overall health and functionality of your API. On the other hand, monitoring is the ongoing process of checking the status of your API to ensure it's functioning as expected while also providing an early warning system for potential issues and improvements. Together, profiling and monitoring your API can lead to a more reliable, efficient, and high-performing service.
+Profiling and monitoring are critical aspects of API design and implementation. Profiling, in this context, refers to the process of analyzing the behavior of your API in order to understand various performance metrics including response times, request rates, error rates, and the overall health and functionality of your API. On the other hand, monitoring is the ongoing process of checking the status of your API to ensure it's functioning as expected while also providing an early warning system for potential issues and improvements. Together, profiling and monitoring your API can lead to a more reliable, efficient, and high-performing service.
+
+Learn more from the following resources:
+
+- [@article@Monitor health and performance of your APIs](https://learning.postman.com/docs/monitoring-your-api/intro-monitors/)
+- [@article@API profiling at Pintrest](https://medium.com/pinterest-engineering/api-profiling-at-pinterest-6fa9333b4961)

src/data/roadmaps/api-design/content/rabbit-mq@H22jAI2W5QLL-b1rq-c56.md

@@ -2,4 +2,9 @@
 
 RabbitMQ is an open-source message-broker software/system that plays a crucial role in API design, specifically in facilitating effective and efficient inter-process communication. It implements the Advanced Message Queuing Protocol (AMQP) to enable secure and reliable data transmission in various formats such as text, binary, or serialized objects. 
 
-In API design, RabbitMQ comes in handy in decoupling application processes for scalability and robustness, whilst ensuring that data delivery occurs safely and seamlessly. It introduces queuing as a way of handling multiple users or service calls at once hence enhancing responsiveness and performance of APIs. Its queue system elegantly digests API request loads, allowing services to evenly process data while preventing overloading.
+In API design, RabbitMQ comes in handy in decoupling application processes for scalability and robustness, whilst ensuring that data delivery occurs safely and seamlessly. It introduces queuing as a way of handling multiple users or service calls at once hence enhancing responsiveness and performance of APIs. Its queue system elegantly digests API request loads, allowing services to evenly process data while preventing overloading.
+
+Learn more from the following resources:
+
+- [@official@RabbitMQ Website](https://www.rabbitmq.com/)
+- [@video@Intro to RabbitMQ](https://www.youtube.com/watch?v=bfVddTJNiAw)

src/data/roadmaps/api-design/content/rate-limiting--throttling@tPVtRV818D8zAAuNbqPNa.md

@@ -1,3 +1,9 @@
 # Rate Limiting / Throttling in API Design
 
-Rate Limiting, often referred to as Throttling, is a fundamental aspect of API Design aimed at controlling the number of requests a client can make to an API within a specified timeframe. This technique ensures fair usage, enhances security, prevents server overload, and allows an even distribution of resources. It also minimizes the risks associated with abusive behaviors or DDoS attacks. Effective rate limiting strategy involves defining the limits based on the API's capacity and clients' reasonable needs, with flexibility to tweak these limits when necessary. Understanding rate limiting and its significance is crucial for building resilient, secure, and scalable API platforms.
+Rate Limiting, often referred to as Throttling, is a fundamental aspect of API Design aimed at controlling the number of requests a client can make to an API within a specified timeframe. This technique ensures fair usage, enhances security, prevents server overload, and allows an even distribution of resources. It also minimizes the risks associated with abusive behaviors or DDoS attacks. Effective rate limiting strategy involves defining the limits based on the API's capacity and clients' reasonable needs, with flexibility to tweak these limits when necessary. Understanding rate limiting and its significance is crucial for building resilient, secure, and scalable API platforms.
+
+Learn more from the following resources:
+
+- [@video@What is Rate Limiting / API Throttling? | System Design Concepts](https://www.youtube.com/watch?v=9CIjoWPwAhU)
+- [@article@API Management 101: Rate Limiting](https://tyk.io/learning-center/api-rate-limiting/)
+- [@article@API Rate Limiting vs. Throttling](https://blog.stoplight.io/best-practices-api-rate-limiting-vs-throttling)

src/data/roadmaps/api-design/content/rate-limiting@O7wjldZ3yTA2s_F-UnJw_.md

@@ -1 +1,3 @@
-# Rate Limiting
+# Rate Limiting in API Design
+
+Rate Limiting is a critical aspect of API Design that dictates the number of API calls a client can make within a specified timeframe. This helps in managing resource allocation, preventing abuse of the API, and maintaining the overall health of the API system. Proper rate limiting measures should be in place to ensure the API's stability, thereby delivering a consistent and reliable service to all consumers. It works primarily by setting a limit on the frequency of client requests, thereby preventing individual users from overloading the system. It is crucial to design and implement rate limiting carefully for maintaining API availability and performance.

src/data/roadmaps/api-design/content/readmecom@LxWHkhlikUaMT2G8YmVDQ.md

@@ -1,3 +1,8 @@
 # Readme.com in the Context of API Design
 
-Readme.com is an invaluable tool in the realm of API Design, renowned for providing a collaborative platform for creating beautiful, dynamic and intuitive documentation. It's a tool which aids developers in outlining clear, comprehensive documentation for their API interfaces. The API documentation created with Readme.com is not just about the presentation of information, but enhances the reader's understanding by making it interactive. This interactive approach encourages practical learning and offers insights into how the API will behave under different circumstances. With Readme.com, developers can create a user-focused documentation environment that streamlines the learning process and makes their APIs easier to consume and implement.
+Readme.com is an invaluable tool in the realm of API Design, renowned for providing a collaborative platform for creating beautiful, dynamic and intuitive documentation. It's a tool which aids developers in outlining clear, comprehensive documentation for their API interfaces. The API documentation created with Readme.com is not just about the presentation of information, but enhances the reader's understanding by making it interactive. This interactive approach encourages practical learning and offers insights into how the API will behave under different circumstances. With Readme.com, developers can create a user-focused documentation environment that streamlines the learning process and makes their APIs easier to consume and implement.
+
+Learn more from the following resources:
+
+- [@official@readme.com](https://readme.com)
+- [@opensource@readmeio](https://github.com/readmeio)

src/data/roadmaps/api-design/content/real-time-apis@JE12g5cqnwmgeTle14Vxw.md

@@ -1,3 +1,8 @@
 # Real-time APIs
 
-In the realm of API Design, Real-time APIs hold significant value as they provide immediate access to the latest data as soon as they become available. Rather than relying on periodic polling for updates, Real-time APIs maintain an open connection between the client and the server which allows immediate, bi-directional data flow. These APIs are commonly used in applications which require real-time information such as live chat programs, financial trading platforms or online multiplayer games. Designing such APIs requires careful consideration of factors such as connection management, data consistency, and efficient handling of high volume data streams.
+In the realm of API Design, Real-time APIs hold significant value as they provide immediate access to the latest data as soon as they become available. Rather than relying on periodic polling for updates, Real-time APIs maintain an open connection between the client and the server which allows immediate, bi-directional data flow. These APIs are commonly used in applications which require real-time information such as live chat programs, financial trading platforms or online multiplayer games. Designing such APIs requires careful consideration of factors such as connection management, data consistency, and efficient handling of high volume data streams.
+
+Learn more from the following resources:
+
+- [@article@What are Realtime APIs?](https://www.pubnub.com/guides/realtime-api/)
+- [@article@What are realtime APIs and when to use them?](https://ably.com/topic/what-is-a-realtime-api)

src/data/roadmaps/api-design/content/reate-limiting@O7wjldZ3yTA2s_F-UnJw_.md

@@ -1,3 +0,0 @@
-# Rate Limiting in API Design
-
-Rate Limiting is a critical aspect of API Design that dictates the number of API calls a client can make within a specified timeframe. This helps in managing resource allocation, preventing abuse of the API, and maintaining the overall health of the API system. Proper rate limiting measures should be in place to ensure the API's stability, thereby delivering a consistent and reliable service to all consumers. It works primarily by setting a limit on the frequency of client requests, thereby preventing individual users from overloading the system. It is crucial to design and implement rate limiting carefully for maintaining API availability and performance.

src/data/roadmaps/api-design/content/rest-principles@9WI_z34jIFXwoUQuChyRU.md

@@ -1,3 +1,8 @@
 # REST Principles in API Design 
 
-REST (Representational State Transfer) is an important architectural style used in API design. It defines a set of rules and conventions through which systems communicate over a network. Key characteristics of REST include statelessness, client-server communication, cacheability, and a uniform interface. Understanding and applying these principles properly can help in designing robust, scalable, and high-performance APIs. REST principles revolve around resources and their manipulation to achieve desired outcomes. By following these principles, developers can ensure that their API design is in line with web standards, thus improving interoperability across different systems.
+REST (Representational State Transfer) is an important architectural style used in API design. It defines a set of rules and conventions through which systems communicate over a network. Key characteristics of REST include statelessness, client-server communication, cacheability, and a uniform interface. Understanding and applying these principles properly can help in designing robust, scalable, and high-performance APIs. REST principles revolve around resources and their manipulation to achieve desired outcomes. By following these principles, developers can ensure that their API design is in line with web standards, thus improving interoperability across different systems.
+
+Learn more from the following resources:
+
+- [@article@REST API Principles | A Comprehensive Overview](https://blog.dreamfactory.com/rest-apis-an-overview-of-basic-principles)
+- [@article@REST principles](https://ninenines.eu/docs/en/cowboy/2.12/guide/rest_principles/)

src/data/roadmaps/api-design/content/restful-apis@BvwdASMvuNQ9DNgzdSZ4o.md

@@ -1,3 +1,8 @@
 # RESTful APIs
 
-RESTful APIs, or Representational State Transfer APIs, are a set of conventions for designing networked applications. They utilize HTTP methods to read, update and delete data. They offer a simple and standardized way to build web services that can be easily consumed by different clients. The key principles of a RESTful API include stateless client-server communication, cacheable data, and a uniform interface, making the API easy to understand, flexible, and scalable. Moreover, it relies heavily on the use of resources and their representations, making it a popular choice in API design due to its performance, scalability, simplicity, and reliability.
+RESTful APIs, or Representational State Transfer APIs, are a set of conventions for designing networked applications. They utilize HTTP methods to read, update and delete data. They offer a simple and standardized way to build web services that can be easily consumed by different clients. The key principles of a RESTful API include stateless client-server communication, cacheable data, and a uniform interface, making the API easy to understand, flexible, and scalable. Moreover, it relies heavily on the use of resources and their representations, making it a popular choice in API design due to its performance, scalability, simplicity, and reliability.
+
+Learn more from the following resources:
+
+- [@article@What is REST?](https://restfulapi.net/)
+- [@article@What is a RESTul API?](https://aws.amazon.com/what-is/restful-api/)

src/data/roadmaps/api-design/content/rfc-7807----problem-details-for-apis@5CxU3inGcSHp-TDg3BQiY.md

@@ -1,3 +1,8 @@
 # RFC 7807 - Problem Details for HTTP APIs in Error Handling
 
-The practice of API Design includes a significant focus on handling errors effectively and transparently. Among the widespread standards being adopted, the RFC 7807 or Problem Details for HTTP APIs plays a crucial role. This specification provides a standardized format for sending problem or error details from an HTTP API so developers engaging with the API do not need to parse non-standard error messages and can anticipate the structure of potential errors. In essence, RFC 7807 improves the usability and comprehension of your API, providing a better developer experience and encouraging the efficient use of your API. Implementing it paves the way to robust and accountable systems, where issues can be traced, identified, and solved more conveniently.
+The practice of API Design includes a significant focus on handling errors effectively and transparently. Among the widespread standards being adopted, the RFC 7807 or Problem Details for HTTP APIs plays a crucial role. This specification provides a standardized format for sending problem or error details from an HTTP API so developers engaging with the API do not need to parse non-standard error messages and can anticipate the structure of potential errors. In essence, RFC 7807 improves the usability and comprehension of your API, providing a better developer experience and encouraging the efficient use of your API. Implementing it paves the way to robust and accountable systems, where issues can be traced, identified, and solved more conveniently.
+
+Learn more from the following resources:
+
+- [@article@RFC 7807 - Problem Details for HTTP APIs](https://datatracker.ietf.org/doc/html/rfc7807)
+- [@article@RFC 9457 - Problem Details for HTTP APIs](https://www.rfc-editor.org/rfc/rfc9457.html)

src/data/roadmaps/api-design/content/role-based-access-control-rbac@wFsbmMi5Ey9UyDADdbdPW.md

@@ -1,3 +1,9 @@
 # Role Based Access Control (RBAC) in API Design
 
-Role-Based Access Control (RBAC) is a method of managing authorization in API design that assigns system access to users based on their role within an organization. RBAC is crucial in controlling which endpoints a user can call, and what operations they are allowed to execute. In the context of API design, RBAC ensures appropriate levels of access for different types of users to guarantee data security and integrity. It simplifies the process of security administration by assigning privileges based on a user's job function, rather than on an individual basis.
+Role-Based Access Control (RBAC) is a method of managing authorization in API design that assigns system access to users based on their role within an organization. RBAC is crucial in controlling which endpoints a user can call, and what operations they are allowed to execute. In the context of API design, RBAC ensures appropriate levels of access for different types of users to guarantee data security and integrity. It simplifies the process of security administration by assigning privileges based on a user's job function, rather than on an individual basis.
+
+Learn more from the following resources:
+
+- [@article@Role-Based Access Control](https://auth0.com/docs/manage-users/access-control/rbac)
+- [@article@What is role-based access control (RBAC)?](https://www.redhat.com/en/topics/security/what-is-role-based-access-control)
+- [@video@Role-based access control (RBAC) vs. Attribute-based access control (ABAC)](https://www.youtube.com/watch?v=rvZ35YW4t5k)

src/data/roadmaps/api-design/content/server-sent-events@iNsXTtcIHsI_i-mCfjGYn.md

@@ -1,3 +1,8 @@
 # Server Sent Events under Real-time APIs
 
-Server-Sent Events (SSE) represent an explicit concept in the design of Real-time APIs. Unlike traditional approaches where a client sends a request and awaits a response from the server, SSE enables a server to push data to clients whenever a particular event takes place. SSE is especially fundamental in API design when it comes to the development of applications where real-time data is essential, such as live news updates, real-time gaming, or live-streaming services. Designing APIs with the SSE approach ensures a more dynamic and responsive user experience.
+Server-Sent Events (SSE) represent an explicit concept in the design of Real-time APIs. Unlike traditional approaches where a client sends a request and awaits a response from the server, SSE enables a server to push data to clients whenever a particular event takes place. SSE is especially fundamental in API design when it comes to the development of applications where real-time data is essential, such as live news updates, real-time gaming, or live-streaming services. Designing APIs with the SSE approach ensures a more dynamic and responsive user experience.
+
+Learn more from the following events:
+
+- [@video@Server-Sent Events | Postman Level Up](https://www.youtube.com/watch?v=KrE044J8jEQ)
+- [@article@Using server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)

src/data/roadmaps/api-design/content/session-based-auth@eQWoy4CpYP3TJL2bbhPB_.md

@@ -4,4 +4,10 @@ Application Programming Interfaces (APIs) are critical for building software app
 
 This method revolves around the server creating a session for the user after they successfully log in, associating it with a session identifier. This Session ID is then stored client-side within a cookie. On subsequent requests, the server validates the Session ID before processing the API call. The server will destroy the session after the user logs out, thereby invalidating the Session ID. 
 
-Understanding Session Based Authentication is crucial for secure API design, especially in scenarios where security is a top priority or in legacy systems where this method is prevalent.
+Understanding Session Based Authentication is crucial for secure API design, especially in scenarios where security is a top priority or in legacy systems where this method is prevalent.
+
+Learn more from the following resources:
+
+- [@official@Session Based Authentication - Roadmap.sh](https://roadmap.sh/guides/session-based-authentication)
+- [@video@Session Based Authentication - Roadmap.sh](https://www.youtube.com/watch?v=gKkBEOq_shs)
+- [@article@Session vs Token Authentication](https://www.authgear.com/post/session-vs-token-authentication)

src/data/roadmaps/api-design/content/simple-json-apis@TVR-SkErlOHbDKLBGfxep.md

@@ -1,3 +1,8 @@
 # Simple JSON APIs
 
-Simple JSON (JavaScript Object Notation) APIs are a popular form of API or "Application Programming Interface" which utilise JSON to exchange data between servers and web applications. This method has gained prominence mainly for its simplicity, light weight, and easy readability. In the context of API design, a well-structured JSON API allows developers to efficiently interact with the backend and retrieve only the data they need in a consistent and comprehensible manner. From reducing redundant data to enabling quick parsing, Simple JSON APIs provide numerous benefits to improve the overall performance of applications. Designing a good JSON API requires careful planning, sound knowledge of HTTP methods, endpoints, error handling mechanisms, and most importantly, a clear understanding of the application's data requirements.
+Simple JSON (JavaScript Object Notation) APIs are a popular form of API or "Application Programming Interface" which utilise JSON to exchange data between servers and web applications. This method has gained prominence mainly for its simplicity, light weight, and easy readability. In the context of API design, a well-structured JSON API allows developers to efficiently interact with the backend and retrieve only the data they need in a consistent and comprehensible manner. From reducing redundant data to enabling quick parsing, Simple JSON APIs provide numerous benefits to improve the overall performance of applications. Designing a good JSON API requires careful planning, sound knowledge of HTTP methods, endpoints, error handling mechanisms, and most importantly, a clear understanding of the application's data requirements.
+
+Learn more from the following resources:
+
+- [@video@JSON API: Explained in 4 minutes (+ EXAMPLES)](https://www.youtube.com/watch?v=N-4prIh7t38)
+- [@opensource@A specification for building JSON APIs](https://github.com/json-api/json-api)

src/data/roadmaps/api-design/content/soap-apis@Wwd-0PjrtViMFWxRGaQey.md

@@ -1,3 +1,8 @@
 # SOAP APIs
 
-SOAP (Simple Object Access Protocol) APIs are a standard communication protocol system that permits programs that run on different operating systems (like Linux and Windows) to communicate using Hypertext Transfer Protocol (HTTP) and its Extensible Markup Language (XML). In the context of API Design, SOAP APIs offer a robust and well-defined process for interaction between various software applications, mostly over a network. They are highly extensible, versatile and support a wide range of communications protocols. Despite being more complex compared to other API types like REST, SOAP APIs ensure high reliability and security, making them the choice for certain business-focused, high-transaction applications.
+SOAP (Simple Object Access Protocol) APIs are a standard communication protocol system that permits programs that run on different operating systems (like Linux and Windows) to communicate using Hypertext Transfer Protocol (HTTP) and its Extensible Markup Language (XML). In the context of API Design, SOAP APIs offer a robust and well-defined process for interaction between various software applications, mostly over a network. They are highly extensible, versatile and support a wide range of communications protocols. Despite being more complex compared to other API types like REST, SOAP APIs ensure high reliability and security, making them the choice for certain business-focused, high-transaction applications.
+
+Learn more from the following resources:
+
+- [@article@What are SOAP APIs?](https://www.indeed.com/career-advice/career-development/what-is-soap-api)
+- [@article@SOAP vs REST 101: Understand The Differences](https://www.soapui.org/learn/api/soap-vs-rest-api/)

src/data/roadmaps/api-design/content/standards-and-compliance@yvdfoly5WHHTq2Puss355.md

@@ -4,4 +4,10 @@ When designing APIs, it's crucial to consider the concept of standards and compl
 
 Compliance on the other hand, emphasizes on meeting protocol requirements or standards such as REST or SOAP. Furthermore, operating within regulated industries can also necessitate certain compliance measures like GDPR, HIPAA and others. Compliance in API Design ensures interoperability and safety of data transmission between systems. 
 
-In essence, Standards and Compliance in API Design contributes towards building more secure, robust, and efficient APIs that are user-friendly and universally understandable.
+In essence, Standards and Compliance in API Design contributes towards building more secure, robust, and efficient APIs that are user-friendly and universally understandable.
+
+Learn more from the following resources:
+
+- [@article@What is API compliance?](https://tyk.io/learning-center/api-compliance/)
+- [@article@What is API compliance and why is it important?](https://www.traceable.ai/blog-post/achieve-api-compliance)
+- [@article@REST API standards](https://www.integrate.io/blog/rest-api-standards/)

src/data/roadmaps/api-design/content/stoplight@OpS2NX1lPTOtfjV1wKtC4.md

@@ -1,3 +1,8 @@
 # Stoplight API Design 
 
-Stoplight is an advanced tool that offers a comprehensive platform for technical teams to handle all aspects of API design. Leveraging Stoplight, teams can design, document and develop APIs in a more collaborative and streamlined manner. It uses an OpenAPI specification and allows users to design APIs visually, making API development easier. With its ability to auto-generate API documentation, performing API mock testing, and providing API management features, Stoplight plays a crucial role in adopting a design-first approach in API development. By using Stoplight, APIs can be designed to be easy-to-use, scalable, and robust from the outset, which ultimately improves the overall development process and quality of the APIs.
+Stoplight is an advanced tool that offers a comprehensive platform for technical teams to handle all aspects of API design. Leveraging Stoplight, teams can design, document and develop APIs in a more collaborative and streamlined manner. It uses an OpenAPI specification and allows users to design APIs visually, making API development easier. With its ability to auto-generate API documentation, performing API mock testing, and providing API management features, Stoplight plays a crucial role in adopting a design-first approach in API development. By using Stoplight, APIs can be designed to be easy-to-use, scalable, and robust from the outset, which ultimately improves the overall development process and quality of the APIs.
+
+Learn more from the following resources:
+
+- [@official@Stoplight Website](https://stoplight.io/)
+- [@opensource@/stoplightio](https://github.com/stoplightio)

src/data/roadmaps/api-design/content/swagger--open-api@5RY7AlfRQydjxWK65Z4cv.md

@@ -1,3 +1,9 @@
 # Swagger / Open API
 
-Swagger, also known as OpenAPI, is a set of tools specifically used for designing, building, and documenting RESTful Web services. API developers heavily rely on it due to its incredible feature for designing APIs with a clear and easy-to-understand approach. By utilizing the OpenAPI Specification (OAS), developers can accurately define a RESTful API that can easily be used across various programming languages. This powerful universal language is a key component for effective and efficient API design.
+Swagger, also known as OpenAPI (not to be confused with OpenAI), is a set of tools specifically used for designing, building, and documenting RESTful Web services. API developers heavily rely on it due to its incredible feature for designing APIs with a clear and easy-to-understand approach. By utilizing the OpenAPI Specification (OAS), developers can accurately define a RESTful API that can easily be used across various programming languages. This powerful universal language is a key component for effective and efficient API design.
+
+Learn more from the following resources:
+
+- [@official@Swagger Website](https://swagger.io/)
+- [@article@What is Swagger?](https://blog.hubspot.com/website/what-is-swagger)
+- [@official@OpenAPI Inititive](https://www.openapis.org/)

src/data/roadmaps/api-design/content/synchronous-vs-asynchronous-apis@--mmTKhG58_elbUqyn90G.md

@@ -2,4 +2,10 @@
 
 When designing APIs, one critical decision is whether to create a synchronous or asynchronous API. Synchronous APIs are those that hold a connection open and wait for a response before moving on, hence operating in a sequential manner. This can lead to efficient, simple-to-understand coding but can pose performance issues when dealing with long tasks since the caller has to wait until the process finishes.
 
-On the other hand, Asynchronous APIs do not wait for a response before moving on to the next task, allowing multiple operations to be executed simultaneously. This can result in improved performance and responsiveness especially in applications that need to handle multiple requests concurrently. However, coding for asynchronous APIs can be complex due to issues such as race conditions and callbacks. Understanding the differences between these two types of API design is crucial for creating efficient and effective APIs.
+On the other hand, Asynchronous APIs do not wait for a response before moving on to the next task, allowing multiple operations to be executed simultaneously. This can result in improved performance and responsiveness especially in applications that need to handle multiple requests concurrently. However, coding for asynchronous APIs can be complex due to issues such as race conditions and callbacks. Understanding the differences between these two types of API design is crucial for creating efficient and effective APIs.
+
+Learn more from the following resources:
+
+- [@article@Asynchronous APIs — Everything You Need to Know](https://blog.hubspot.com/website/asynchronous-api)
+- [@article@The Differences Between Synchronous and Asynchronous APIs](https://nordicapis.com/the-differences-between-synchronous-and-asynchronous-apis/)
+- [@article@Understanding Asyncronous APIs](https://blog.postman.com/understanding-asynchronous-apis/)

src/data/roadmaps/api-design/content/token-based-auth@QTH7sy9uQZWl6ieBz7erY.md

@@ -1,3 +1,9 @@
 # Token Based Auth in API Design
 
-Token-based authentication is a crucial aspect of API design. It involves providing the user with a token that validates their identity after they have successfully logged in. Once the token is obtained, users can use it to access resources and services provided by the API. This token is usually passed in the headers of subsequent HTTP requests done by the client. One key advantage of token-based auth is that tokens can be created and checked by the server without storing them persistently, which can help to scale applications more easily. This authentication method enhances the security and scalability of web applications and it is mainly used in modern API strategies, including RESTful APIs.
+Token-based authentication is a crucial aspect of API design. It involves providing the user with a token that validates their identity after they have successfully logged in. Once the token is obtained, users can use it to access resources and services provided by the API. This token is usually passed in the headers of subsequent HTTP requests done by the client. One key advantage of token-based auth is that tokens can be created and checked by the server without storing them persistently, which can help to scale applications more easily. This authentication method enhances the security and scalability of web applications and it is mainly used in modern API strategies, including RESTful APIs.
+
+Learn more from the following resources:
+
+- [@article@What Is Token-Based Authentication?](https://www.okta.com/uk/identity-101/what-is-token-based-authentication/)
+- [@video@Session vs Token Authentication in 100 Seconds](https://www.youtube.com/watch?v=UBUNrFtufWo)
+- [@video@Token based auth](https://www.youtube.com/watch?v=woNZJMSNbuo)

src/data/roadmaps/api-design/content/understand-tcp--ip@KG3wO86F8Of27fU7QRcsn.md

@@ -1,3 +1,9 @@
 # Understand TCP / IP
 
-When designing APIs, an essential building block is the understanding of TCP/IP. TCP/IP, standing for Transmission Control Protocol/Internet Protocol, is the suite of communications protocols used to connect hosts on the Internet. It provides ordered, error-checked delivery of streams of bytes from a program on one computer to another program on another computer. If you want to understand how APIs communicate over networks, knowing the fundamental working of TCP/IP is indispensable. Fully appreciating this topic will strengthen your grasp on API design and help you make more informed decisions when creating APIs.
+When designing APIs, an essential building block is the understanding of TCP/IP. TCP/IP, standing for Transmission Control Protocol/Internet Protocol, is the suite of communications protocols used to connect hosts on the Internet. It provides ordered, error-checked delivery of streams of bytes from a program on one computer to another program on another computer. If you want to understand how APIs communicate over networks, knowing the fundamental working of TCP/IP is indispensable. Fully appreciating this topic will strengthen your grasp on API design and help you make more informed decisions when creating APIs.
+
+Learn more from the following resources:
+
+- [@article@What is Transmission Control Protocol TCP/IP?](https://www.fortinet.com/resources/cyberglossary/tcp-ip)
+- [@article@What is TCP/IP?](https://www.cloudflare.com/en-gb/learning/ddos/glossary/tcp-ip/)
+- [@video@what is TCP/IP and OSI?](https://www.youtube.com/watch?v=CRdL1PcherM)

src/data/roadmaps/api-design/content/unit-testing@JvmW78cDm84GNhq8VEYZp.md

@@ -1,3 +1,8 @@
 # Unit Testing in API Design
 
-Unit Testing, in the context of API design, refers to the process of testing the individual components or functions of an API independently to ensure that each part is working correctly. It is typically performed at the development stage. The chief goal of Unit Testing is to isolate each component and validate its correct operation, thereby increasing confidence in the stability of the API as a whole. It lays a solid foundation for integration testing and ultimately leads to reliable, bug-free APIs. Whether your API is RESTful, SOAP, or GraphQL, unit testing is a critical step in API design and development.
+Unit Testing, in the context of API design, refers to the process of testing the individual components or functions of an API independently to ensure that each part is working correctly. It is typically performed at the development stage. The chief goal of Unit Testing is to isolate each component and validate its correct operation, thereby increasing confidence in the stability of the API as a whole. It lays a solid foundation for integration testing and ultimately leads to reliable, bug-free APIs. Whether your API is RESTful, SOAP, or GraphQL, unit testing is a critical step in API design and development.
+
+Learn more from the following resources:
+
+- [@article@How to write unit tests for your REST API](https://medium.com/@oyetoketoby80/how-to-write-unit-test-for-your-rest-api-f8f71376273f)
+- [@article@Unit test a REST API](https://www.testim.io/blog/unit-test-rest-api/)

src/data/roadmaps/api-design/content/uri-design@b3qRTLwCC_9uDoPGrd9Bu.md

@@ -1,3 +1,8 @@
 # URI Design in API
 
-URI (Uniform Resource Identifier) is a string of characters used to identify a name or a resource on the Internet. Designing URIs carefully is a crucial part of creating a smooth API interface that is easy to understand, remember and use. Good URI design ensures that related resources are grouped together in a logical manner and can greatly impact the usability and maintainability of an API. It involves crafting standardised, intuitive HTTP paths that take advantage of the hierarchical nature of URLs to provide a better structure to the API. This hierarchy can then be used to expand the API over time without breaking existing clients' functionality.
+URI (Uniform Resource Identifier) is a string of characters used to identify a name or a resource on the Internet. Designing URIs carefully is a crucial part of creating a smooth API interface that is easy to understand, remember and use. Good URI design ensures that related resources are grouped together in a logical manner and can greatly impact the usability and maintainability of an API. It involves crafting standardised, intuitive HTTP paths that take advantage of the hierarchical nature of URLs to provide a better structure to the API. This hierarchy can then be used to expand the API over time without breaking existing clients' functionality.
+
+Learn more from the following resources:
+
+- [@article@Guidelines for URI design](https://css-tricks.com/guidelines-for-uri-design/)
+- [@article@Designing URIs](https://www.oreilly.com/library/view/restful-web-services/9780596809140/ch04.html)

src/data/roadmaps/api-design/content/url-query--path-parameters@P-rGIk50Bg7nFmWieAW07.md

@@ -1,3 +1,9 @@
 # URL, Query & Path Parameters
 
-When designing APIs, an integral part involves dealing with uniform resource locators (URLs), query parameters, and path parameters. These components play crucial parts in how the API sends and retrieves data. The URL forms the basis of the API given that it identifies the resource on the server. Query parameters are used to filter specific results, sorting or showing specific data fields. On the other hand, Path parameters serve as placeholders for variable data that will be input into the URL, allowing us to customize the data response. Understanding the usage of URL, query, and path parameters is of utmost importance for creating efficient, scalable and user-friendly APIs.
+When designing APIs, an integral part involves dealing with uniform resource locators (URLs), query parameters, and path parameters. These components play crucial parts in how the API sends and retrieves data. The URL forms the basis of the API given that it identifies the resource on the server. Query parameters are used to filter specific results, sorting or showing specific data fields. On the other hand, Path parameters serve as placeholders for variable data that will be input into the URL, allowing us to customize the data response. Understanding the usage of URL, query, and path parameters is of utmost importance for creating efficient, scalable and user-friendly APIs.
+
+Learn more from the following resources:
+
+- [@article@Understanding Path Variables and Query Parameters in HTTP Requests](https://medium.com/@averydcs/understanding-path-variables-and-query-parameters-in-http-requests-232248b71a8)
+- [@article@Describing parameters](https://swagger.io/docs/specification/describing-parameters/)
+- [@article@Path parameters](https://help.iot-x.com/api/how-to-use-the-api/parameters/path-parameters)

src/data/roadmaps/api-design/content/versioning-strategies@itILK2SXvLvAjk1Kul7EK.md

@@ -1,3 +1,9 @@
 # Versioning Strategies in API Design 
 
-API Versioning is a critical component of API Design and Management. As the APIs evolve over time to meet the new business requirements and functionality enhancements, it is crucial to manage the changes in a way that doesn't break the existing client applications. This calls for effective versioning strategies in API design. There are different versioning strategies like URI versioning, Request Header versioning, and Media Type versioning which are adopted based on the ease of implementation, client compatibility, and accessibility. Understanding each strategy and its pros and cons can lead to better API Design and maintainability.
+API Versioning is a critical component of API Design and Management. As the APIs evolve over time to meet the new business requirements and functionality enhancements, it is crucial to manage the changes in a way that doesn't break the existing client applications. This calls for effective versioning strategies in API design. There are different versioning strategies like URI versioning, Request Header versioning, and Media Type versioning which are adopted based on the ease of implementation, client compatibility, and accessibility. Understanding each strategy and its pros and cons can lead to better API Design and maintainability.
+
+Learn more from the following resources:
+
+- [@article@What is API versioning?](https://www.postman.com/api-platform/api-versioning/)
+- [@article@4 API versioning best practices](https://kodekloud.com/blog/api-versioning-best-practices/)
+- [@video@Versioning your APIs](https://www.youtube.com/watch?v=Np_Jr6AvCOc)

src/data/roadmaps/api-design/content/web-sockets@UQ8N7gcVpRLAYXgUNHBt5.md

@@ -1,3 +1,9 @@
 # Web Sockets in API Design
 
-Web Sockets provide a long-lived connection between a client and a server over which messages can be sent bi-directionally, in real-time. They play a crucial role in creating real-time APIs by offering a faster and more efficient communication method over the traditional HTTP. In the context of API Design, Web Sockets are used for developing APIs that require real-time data transfer, such as chat applications, live sports updates, and real-time analytics. This paradigm shift from traditional HTTP-based API design to Web Socket-based API design helps create APIs that are more responsive, dynamic, and efficient in handling real-time data.
+Web Sockets provide a long-lived connection between a client and a server over which messages can be sent bi-directionally, in real-time. They play a crucial role in creating real-time APIs by offering a faster and more efficient communication method over the traditional HTTP. In the context of API Design, Web Sockets are used for developing APIs that require real-time data transfer, such as chat applications, live sports updates, and real-time analytics. This paradigm shift from traditional HTTP-based API design to Web Socket-based API design helps create APIs that are more responsive, dynamic, and efficient in handling real-time data.
+
+Learn more from the following resources:
+
+- [@article@The WebSocket API (WebSockets)](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API)
+- [@article@What are websockets?](https://www.pubnub.com/guides/websockets/)
+- [@video@How web sockets work](https://www.youtube.com/watch?v=pnj3Jbho5Ck)

src/data/roadmaps/api-design/content/webhooks-vs-polling@75NVxS0iwoQXxOHCkWQxH.md

@@ -1,3 +1,8 @@
 # Webhooks vs Polling in API Design
 
-When it comes to managing server communication and data exchange in API design, two commonly used methods are webhooks and polling. These two strategies handle updates and data synchronization in different ways. Polling is a technique where the client repeatedly makes a request to the server to check for updates. In this case, it's the client determining the rate of information exchange. Conversely, webhooks operate on a 'push' mechanism. The server sends updates to the client as they happen, providing real-time, efficient data synchronization. Determining which method to use often depends on the specifics of the API design requirement including the frequency of data changes, server load, and application's real-time need.
+When it comes to managing server communication and data exchange in API design, two commonly used methods are webhooks and polling. These two strategies handle updates and data synchronization in different ways. Polling is a technique where the client repeatedly makes a request to the server to check for updates. In this case, it's the client determining the rate of information exchange. Conversely, webhooks operate on a 'push' mechanism. The server sends updates to the client as they happen, providing real-time, efficient data synchronization. Determining which method to use often depends on the specifics of the API design requirement including the frequency of data changes, server load, and application's real-time need.
+
+Learn more from the following resources:
+
+- [@article@When to Use Webhooks, WebSocket, Pub/Sub, and Polling](https://hookdeck.com/webhooks/guides/when-to-use-webhooks)
+- [@article@Polling vs webhooks: when to use one over the other](https://www.merge.dev/blog/webhooks-vs-polling)