= {
+ course: 'bg-yellow-300',
+};
+
+type TopicDetailLinkProps = {
+ url: string;
+ onClick?: () => void;
+ type: AllowedLinkTypes;
+ title: string;
+ isPaid?: boolean;
+};
+
+export function TopicDetailLink(props: TopicDetailLinkProps) {
+ const { url, onClick, type, title, isPaid = false } = props;
+
+ return (
+
+
+ {type === 'opensource' ? (
+ <>
+ {url.includes('github') && 'GitHub'}
+ {url.includes('gitlab') && 'GitLab'}
+
+ ) : (
+ type
+ )}
+
+ {title}
+
+ );
+}
diff --git a/src/components/UserPublicProfile/UserPublicProfileHeader.tsx b/src/components/UserPublicProfile/UserPublicProfileHeader.tsx
index c1f172df8..81c3f5646 100644
--- a/src/components/UserPublicProfile/UserPublicProfileHeader.tsx
+++ b/src/components/UserPublicProfile/UserPublicProfileHeader.tsx
@@ -27,7 +27,7 @@ export function UserPublicProfileHeader(props: UserPublicProfileHeaderProps) {
: '/images/default-avatar.png'
}
alt={name}
- className="h-32 w-32 rounded-full"
+ className="h-32 w-32 object-cover rounded-full"
/>
diff --git a/src/data/guides/backend-project-ideas.md b/src/data/guides/backend-project-ideas.md
index 450cfb750..b956a2e2f 100644
--- a/src/data/guides/backend-project-ideas.md
+++ b/src/data/guides/backend-project-ideas.md
@@ -385,7 +385,7 @@ As a recommendation for technology implementing this project, [Socket.io](http:/
-For this particular backend project, we’re not going to focus on coding, but rather on backend tools and their configuration. A [CDN](https://aws.amazon.com/es/what-is/cdn/) (or Content Delivery Network) is a platform that allows you to serve static content (like text files, images, audio, etc) safely and reliably.
+For this particular backend project, we’re not going to focus on coding, but rather on backend tools and their configuration. A [CDN](https://aws.amazon.com/what-is/cdn/) (or Content Delivery Network) is a platform that allows you to serve static content (like text files, images, audio, etc) safely and reliably.
Instead of having all files inside the same server, the content is replicated and distributed across a network of servers that can provide you with the files at any given point in time.
@@ -459,4 +459,4 @@ Feel free to add extra commands to make the navigation even more interactive.
With the last of our backend project ideas, you’ve covered all the major areas involved in backend development and you’re more than ready to apply for a backend development job if you haven’t already.
-If you find a piece of technology that wasn’t covered here, you’ll have the skills required to pick it up in no time.
\ No newline at end of file
+If you find a piece of technology that wasn’t covered here, you’ll have the skills required to pick it up in no time.
diff --git a/src/data/guides/backend-technologies.md b/src/data/guides/backend-technologies.md
new file mode 100644
index 000000000..147fe25e3
--- /dev/null
+++ b/src/data/guides/backend-technologies.md
@@ -0,0 +1,452 @@
+---
+title: 'Top 10+ Backend Technologies to Use in @currentYear@: Expert Advice'
+description: 'Looking for the best backend technologies in @currentYear@? Check out our expert list of top tools for developers.'
+authorId: fernando
+excludedBySlug: '/backend/technologies'
+seo:
+ title: 'Top 10+ Backend Technologies to Use in @currentYear@: Expert Advice'
+ description: 'Looking for the best backend technologies in @currentYear@? Check out our expert list of top tools for developers.'
+ ogImageUrl: 'https://assets.roadmap.sh/guest/backend-technologies-pnof4.jpg'
+isNew: true
+type: 'textual'
+date: 2024-08-27
+sitemap:
+ priority: 0.7
+ changefreq: 'weekly'
+tags:
+ - 'guide'
+ - 'textual-guide'
+ - 'guide-sitemap'
+---
+
+
+
+Backend technologies are the key to building robust and scalable applications. They power all platforms and products on the web without even being visible to the users.
+
+While backend programming languages form the foundation of backend development, they aren't enough on their own. Understanding and leveraging the right backend technologies can significantly enhance your development workflow and application performance.
+
+As a [backend developer](https://roadmap.sh/backend), you’ll be faced with too many options while trying to define your backend technology stack, and that can feel overwhelming.
+
+So, in this article, we’re going to cover the best backend technologies in the following categories:
+
+- Databases
+- Version control systems
+- Containerization and orchestration
+- Cloud platforms
+- APIs & Web Services
+- Caching systems
+- Message brokers
+- Authentication and Authorization systems
+- CI/CD
+- Monitoring & Logging
+
+These should help you stay up-to-date or reach the required level to succeed as a backend developer.
+
+## Databases
+
+
+
+We can’t have a list of backend technologies to learn without covering databases. After all, databases are a core piece of the best backend technologies in use today and the backbone of any application, providing the necessary storage and retrieval of data. Choosing the right type of database depends on your application's requirements, such as data consistency, scalability, and complexity.
+
+### SQL Databases
+
+SQL databases (or relational databases as they’re also called) bring structure to your data and a standard querying language known as SQL.
+
+#### PostgreSQL
+
+PostgreSQL is an advanced open-source relational database known for its reliability and extensive feature set. It supports a wide range of data types and complex queries, making it ideal for applications that require ACID compliance and advanced data handling capabilities. PostgreSQL is commonly used in financial systems, data warehousing, and applications needing strong data integrity and complex reporting.
+
+PostgreSQL also offers robust support for JSON and JSONB data types, enabling seamless integration of relational and NoSQL capabilities within a single database system. Its powerful indexing mechanisms ensure efficient query performance even with large datasets.
+
+Additionally, PostgreSQL provides advanced security features like row-level security and multi-factor authentication, making it a secure choice for handling sensitive data.
+
+#### MySQL
+
+MySQL is a widely used open-source SQL database praised for its speed, reliability, and ease of use. It is particularly popular backend technology for web applications and online transaction processing (OLTP) due to its performance and robust community support. MySQL is often the database of choice for content management systems, e-commerce platforms, and logging applications.
+
+MySQL also supports a variety of storage engines, including InnoDB, which provides ACID compliance, foreign key support, and transaction-safe operations, making it suitable for a wide range of applications.
+
+Its replication capabilities, including master-slave and group replication, ensure high availability and scalability for large-scale deployments. Additionally, MySQL offers advanced security features such as data encryption, user authentication, and role-based access control, enhancing its suitability for handling sensitive data.
+
+#### Microsoft SQL Server
+
+SQL Server is a relational database management system from Microsoft that offers great performance, scalability, and deep integration with other Microsoft products. It provides comprehensive tools for database management, including advanced analytics and business intelligence features. SQL Server is ideal for enterprise-level applications, data warehousing, and environments where integration with Microsoft services, such as Azure, is beneficial.
+
+MSSQL Server also includes robust security features, such as transparent data encryption, dynamic data masking, and advanced threat protection, making it a trusted choice for handling sensitive data. It supports a wide range of data types, including spatial and XML data, and offers powerful indexing and query optimization techniques to ensure efficient data retrieval and processing.
+
+SQL Server's integration with Visual Studio and other Microsoft development tools helps to streamline the development process.
+
+#### SQLite
+
+SQLite is a self-contained, serverless, and zero-configuration database engine known for its simplicity and ease of use. It is lightweight and efficient, making it perfect for small to medium-sized applications, mobile apps, desktop applications, and prototyping. SQLite is embedded within the application, eliminating the need for a separate database server, which simplifies deployment and maintenance.
+Its single-disk file format makes it highly portable across various operating systems and platforms.
+SQLite's efficient memory and disk usage allow it to perform well even on devices with limited resources, such as IoT devices and embedded systems.
+
+This makes SQLite an excellent choice for applications where simplicity, reliability, and low overhead are essential.
+
+### NoSQL Databases
+
+On the other hand, NoSQL databases allow for more flexibility by removing the need for a fixed schema and structure to your data. Each solution presented here covers a different type of unstructured database, and it’s up to you to decide if that focus actually makes sense for your business logic or not.
+
+#### MongoDB
+
+MongoDB is a document-oriented database that offers flexibility and scalability. It handles unstructured data with ease, making it ideal for applications with large-scale data and real-time analytics. MongoDB is commonly used in content management systems, e-commerce platforms, and applications that require a dynamic schema. Its ability to store data in JSON-like documents allows for easy data retrieval and manipulation.
+
+#### DynamoDB
+
+DynamoDB is a fully managed NoSQL database service provided by AWS. It is designed for high-performance applications requiring seamless scalability and high availability. DynamoDB is best suited for high-traffic web applications, gaming, and IoT applications. Its serverless nature means it can automatically scale up or down based on demand, ensuring consistent performance and cost-efficiency.
+
+#### Cassandra
+
+Cassandra is an open-source distributed NoSQL database known for its high availability and fault tolerance without compromising performance. It is ideal for large-scale applications and real-time big data analytics. Cassandra's distributed architecture makes it perfect for environments requiring continuous availability and the ability to handle large amounts of data across multiple nodes. It is commonly used in social media platforms, recommendation engines, and other data-intensive applications.
+
+## Version Control Systems
+
+
+
+Version control systems are essential for managing changes to source code over time, allowing multiple developers to collaborate effectively and maintain a history of changes.
+
+### Git
+
+When it comes to picking the right version control tool, Git is the most widely used one. It provides a powerful, flexible, and distributed model for tracking changes. Git’s architecture supports nonlinear development, allowing multiple branches to be created, merged, and managed independently. This makes Git essential for code collaboration and version tracking, making it a foundational tool for any developer.
+
+Let’s go through some of the key benefits that make Git one of the leading backend technologies in web development.
+
+#### Distributed Version Control
+
+Unlike centralized version control systems (CVCS) where a single central repository holds the entire project history, Git allows each developer to have a complete copy of the repository, including its history. This decentralized approach enhances collaboration and ensures that work can continue even if the central server is down.
+
+#### Branching and Merging
+
+**Branching**: Git’s lightweight branching model allows developers to create, delete, and switch between branches effortlessly. This facilitates isolated development of features, bug fixes, or experiments without impacting the main codebase.
+
+**Merging**: Git provides powerful merging capabilities to integrate changes from different branches. Tools like merge commits and rebasing help manage and resolve conflicts, ensuring a smooth integration process.
+
+#### Performance
+
+Git is designed to handle everything from small to very large projects with speed and efficiency. Its performance for both local operations (like committing and branching) and remote operations (like fetching and pushing changes) is optimized, making it suitable for high-performance needs.
+
+#### Commit History and Tracking
+
+Commit Granularity: Git encourages frequent commits, each with a descriptive message, making it easier to track changes, understand the project history, and identify when and why a change was made.
+
+**History Viewing**: Commands like git log, git blame, and git bisect allow developers to explore the project’s history, pinpoint the introduction of bugs, and understand the evolution of the codebase.
+
+#### Collaboration
+
+While strictly not part of Git’s feature set, these functionalities enhance the basic set of features provided by the version control system.
+
+**Pull Requests**: Platforms like GitHub, GitLab, and Bitbucket build on Git’s capabilities, offering features like pull requests to facilitate code reviews and discussions before integrating changes into the main branch.
+
+**Code Reviews**: Integrating with continuous integration (CI) systems, Git platforms enable automated testing and code quality checks, ensuring that changes meet project standards before merging.
+
+#### Staging Area
+
+Git’s staging area (or index) provides an intermediate area where changes can be formatted and reviewed before committing. This allows for more granular control over what changes are included in a commit.
+
+### GitHub
+
+GitHub is a web-based platform that leverages Git for version control. It provides an extensive list of collaborative features, including (as already mentioned) pull requests, code reviews, and project management tools.
+
+#### Key Features and Benefits
+
+**Pull Requests and Code Reviews**: Facilitate discussions around proposed changes before integrating them into the main codebase. Developers can review code, leave comments, and suggest improvements. Built-in tools for reviewing code changes ensure collaborations are following coding standards and catch potential issues early.
+
+**Project Management**: GitHub Issues allow tracking of bugs, enhancements, and tasks. Milestones help in organizing issues into targeted releases or sprints. Kanban-style boards provide a visual way to manage tasks, track progress, and organize workflows.
+
+**Continuous Integration and Deployment**: Automate workflows for CI/CD, testing, deployment, and more. GitHub Actions supports custom scripts and pre-built actions to streamline DevOps processes.
+
+**Community and Collaboration**: Developers can host static websites directly from a GitHub repository with Github Pages, they’re ideal for project documentation or personal websites. Integrated wikis can be used for detailed project documentation. And through forking, starring, and following repositories the platform encourages collaboration and knowledge sharing.
+
+GitHub’s extensive features and strong community support make it the de facto choice for many companies and developers, both for open-source and private projects.
+
+### GitLab
+GitLab is a web-based platform for version control using Git, known for its robust CI/CD pipeline integration. It offers a comprehensive set of tools for the entire DevOps lifecycle, making it suitable for continuous integration, deployment, and monitoring.
+
+#### Key Features and Benefits
+
+**Integrated CI/CD**: Built-in continuous integration and continuous deployment pipelines allow backend developers to automate building, testing, and deploying code changes. With Gitlabs they can even automatically configure CI/CD pipelines, deploy applications, and monitor performance, all through the same platform.
+
+**Security and Compliance**: Gitlabs provides key security capabilities for backend development: built-in static and dynamic application security testing (SAST/DAST).
+
+**Collaboration and Communication**: Instead of Pull Requests like Github, Gitlabs provides the concept of “Merge Requests”: a simplified code review process with inline comments and suggestions.
+
+GitLab’s all-in-one platform makes it an excellent choice for teams looking to streamline their DevOps processes and improve collaboration and productivity.
+
+### Bitbucket
+
+Bitbucket is a Git-based source code repository hosting service that provides both commercial plans and free accounts for small teams. It integrates seamlessly with Atlassian products like Jira and Trello, making it a great choice for teams already using these tools.
+
+**Repository Hosting**: Bitbucket supports both Git and Mercurial version control systems. And it offers unlimited private repositories for teams.
+
+**Integration with Atlassian Products**: Seamlessly integrates with Jira for issue tracking and project management. It can create branches from Jira issues and view development progress which is a fantastic integration for big teams using both tools. If, on the other hand, you’re using Trello, it can connect to Trello’s boards for visual task management and tracking.
+
+**Continuous Integration and Deployment**: Integrated CI/CD service for automating builds, tests, and deployments. It can be configured with a YAML file for custom workflows.
+
+**Security and Permissions**: Control who accesses specific branches to enforce workflows and protect critical branches. You can even enhance security with two-factor authentication.
+
+Bitbucket’s integration with Atlassian’s suite of products, along with its robust CI/CD capabilities, make it an attractive option for teams seeking a tightly integrated development and project management environment.
+
+## Containerization and Orchestration
+
+
+
+While backend developers aren’t always directly involved in the deployment process, understanding the basics of containerization and orchestration can help them work and interact with the team in charge of devops (who usually set up these CI/CD pipelines).
+
+While this is not an exhaustive list of backend technologies, the two main ones to learn about are:
+
+### Docker
+
+Docker is a platform for developing, shipping, and running applications in containers. Containers package software and its dependencies, ensuring it runs consistently across different environments. Docker simplifies application deployment and testing, making it ideal for microservices architectures and continuous integration/continuous deployment (CI/CD) pipelines.
+
+### Kubernetes
+
+Kubernetes is an open-source system for automating the deployment, scaling, and management of containerized applications. It orchestrates containers across clusters of machines, providing high availability, scalability, and efficient resource utilization. Kubernetes is perfect for complex, large-scale applications requiring robust infrastructure management and automated scaling.
+
+## Cloud Platforms
+
+
+
+Cloud platforms provide a range of services and infrastructure that allow developers to deploy, manage, and scale applications without maintaining physical servers. Mind you, the “cloud” is nothing else than someone else’s servers that you don’t have to manage.
+
+These platforms all offer very similar types of managed services (each with its own flavor) that allow you to set up powerful and scalable infrastructures with a few clicks.
+
+### Amazon Web Services (AWS)
+
+Amazon Web Services (AWS) is a very complete cloud computing platform offered by Amazon. It provides a broad range of services, including computing power, storage solutions, and databases, catering to various needs and applications.
+
+#### Key Characteristics of AWS
+
+**Scalability**: AWS provides scalable solutions that allow businesses to easily adjust resources based on demand.
+Global Reach: With data centers located worldwide, AWS offers high availability and low latency for global applications.
+
+**Diverse Service Offerings**: AWS offers a wide range of services, including EC2 for computing, S3 for storage, and RDS for databases.
+
+**Security and Compliance**: AWS provides robust security features and complies with numerous industry standards and regulations.
+
+**Cost Management**: Flexible pricing models and cost management tools help businesses optimize their cloud spending.
+
+### Google Cloud Platform (GCP)
+
+Google Cloud Platform (GCP) is a suite of cloud computing services provided by Google. Like AWS and Microsoft Azure, GCP offers a variety of services, including computing power, storage, machine learning, and data analytics.
+
+#### Key Characteristics of GCP
+
+**AI and Machine Learning**: GCP excels in providing advanced AI and machine learning tools, leveraging Google's expertise.
+
+**Big Data and Analytics**: GCP offers powerful analytics tools, including BigQuery, for handling large-scale data processing.
+
+**Networking**: GCP provides a robust and secure global network infrastructure.
+
+**Integration with Google Services**: Seamless integration with Google Workspace and other Google services enhances productivity and collaboration.
+
+**Open Source Support**: GCP supports various open-source technologies, promoting flexibility and innovation.
+
+### Microsoft Azure
+
+Microsoft Azure is a cloud computing service created by Microsoft, offering a wide range of cloud services, including those for computing, analytics, storage, and networking.
+
+#### Key Characteristics of Microsoft Azure
+
+**Integration with Microsoft Products**: Azure offers seamless integration with popular Microsoft software and services.
+
+**Hybrid Cloud Capabilities**: Azure supports hybrid cloud environments, enabling smooth integration between on-premises and cloud resources.
+
+**Comprehensive Service Range**: Azure provides a broad spectrum of services, including Azure Virtual Machines, Azure SQL Database, and Azure DevOps.
+
+**Enterprise-Grade Security**: Azure emphasizes security with advanced features and compliance with industry standards.
+
+**Developer and IT Pro Tools**: Azure offers a wide range of tools for developers and IT professionals, including Visual Studio and Azure DevOps.
+
+At a high level, all of these providers are very similar to each other, to the point where backend developers experienced in one of them, can extrapolate their understanding of the environment into others with minimum ramp-up time.
+
+## APIs and Web Services
+
+
+
+APIs (or Application Programming Interfaces) and web services are another mandatory incorporation to the list of top backend technologies any developer should keep in mind. They enable communication between different software systems.
+
+The three most common types of APIs right now, are REST, GraphQL and gPRC, let’s take a closer look at each one of them.
+
+### REST
+
+REST is a standard architecture for web services, known for its simplicity and scalability. It operates on stateless principles and uses standard HTTP methods (GET, POST, PUT, DELETE) to perform CRUD (Create, Read, Update, Delete) operations. RESTful APIs are typically used to access and manipulate web resources using URLs.
+
+REST is ideal for web applications and services due to its ease of implementation and broad compatibility with various web technologies. It is commonly used for developing APIs for web and mobile applications, providing endpoints that clients can interact with to perform various operations. RESTful APIs are also ideal for integrating with third-party services, enabling data exchange and interaction between different systems.
+
+#### Key Characteristics of REST
+
+**Statelessness**: Each request from a client contains all the information needed to process the request, without relying on stored context on the server.
+
+**Uniform Interface**: REST APIs follow standard conventions, making them easy to understand and use. This includes using standard HTTP methods and status codes.
+
+**Client-Server Architecture**: Separates the client and server concerns, improving scalability and flexibility. Clients handle the user interface and user experience, while servers handle data storage and business logic.
+
+**Cacheability**: Responses from REST APIs can be cached to improve performance, reducing the need for repeated requests.
+
+**Layered System**: REST allows for a layered system architecture, enabling intermediaries like load balancers and proxy servers to enhance security, performance, and scalability.
+
+If you’d like to know more about REST, you can read the full definition directly from [its source here](https://ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm).
+
+### GraphQL
+
+GraphQL is a query language for APIs and a runtime for executing those queries by using a type system you define for your data. Unlike REST, where multiple endpoints return fixed data structures, GraphQL allows clients to request exactly the data they need. This flexibility reduces the amount of data transferred over the network and can significantly improve performance.
+
+GraphQL is ideal for applications with complex and dynamic data requirements.
+
+#### Key Characteristics of GraphQL
+
+**Declarative Data Fetching**: Clients specify the structure of the response, ensuring they receive only the data they need.
+
+**Strongly Typed Schema**: The API schema is strongly typed, providing clear and detailed documentation of available data and operations.
+
+**Single Endpoint**: Unlike REST, GraphQL uses a single endpoint to serve all requests, simplifying the API architecture.
+
+**Real-time Data**: Supports real-time updates through subscriptions, enabling clients to receive live data changes.
+
+### gRPC
+
+gRPC is a high-performance, open-source RPC (Remote Procedure Call) framework developed by Google. gRPC is designed for low-latency, high-throughput communication, making it suitable for microservices architectures and real-time communication systems.
+
+gRPC is ideal for applications that require efficient, reliable, and bi-directional communication.
+
+#### Key Characteristics of gRPC
+
+**Protocol Buffers**: Uses Protocol Buffers for compact, efficient, and platform-neutral serialization of structured data.
+
+**HTTP/2**: Utilizes HTTP/2 for multiplexing, flow control, header compression, and efficient binary transport.
+
+**Bi-directional Streaming**: Supports multiple types of streaming, including client-side, server-side, and bi-directional streaming.
+
+**Cross-Language Compatibility**: Provides support for multiple backend programming languages, enabling interoperability between different systems.
+
+## Caching Systems
+
+
+
+Caching systems store copies of frequently accessed data to reduce latency and improve application performance. They are essential for speeding up data retrieval and reducing the load on primary data stores.
+
+Implementing a successful caching strategy is not trivial, and one key aspect of it is the backend technology used for the implementation. While there might be multiple options out there, the industry currently recognizes only one de facto choice: Redis.
+
+### Redis: a fast in-memory storage solution
+
+Redis is an in-memory data structure store that can function as a database, cache, and message broker. It supports various data structures such as strings, hashes, lists, sets, sorted sets, bitmaps, hyperloglogs, and with the right add-ons, even vectors. Redis uses a key-value storage mechanism, which makes it simple yet powerful for a wide range of use cases.
+
+Let’s quickly review some of the characteristics of Redis that make it such a fantastic option.
+
+#### High Availability and Scalability
+
+- **Redis Sentinel**: Provides high availability and monitoring, automatically promoting a slave to master in case of failure, ensuring minimal downtime.
+
+- **Redis Cluster**: Supports automatic sharding, allowing Redis to scale horizontally. It partitions data across multiple nodes, ensuring that the system can handle large datasets and high throughput.
+
+#### Performance and Use Cases
+
+Redis's in-memory architecture gives it unmatched I/O speed, making it ideal for real-time applications such as:
+
+- **Gaming**: Managing leaderboards, player sessions, and real-time statistics.
+- **Chat Applications**: Storing messages, user presence information, and delivering real-time notifications.
+- **Analytics**: Real-time data processing and analytics, where rapid data access and manipulation are crucial.
+- **Caching**: Reducing database load by caching frequently accessed data, improving application response times.
+
+#### Persistence and Durability
+
+- **RDB (Redis Database)**: Creates snapshots of the dataset at specified intervals, allowing data to be restored from the last snapshot.
+- **AOF (Append Only File)**: Logs every write operation received by the server, providing a more durable solution that can replay the log to reconstruct the dataset.
+- **Hybrid Approach**: Combining RDB and AOF to leverage the benefits of both methods, balancing performance and data durability.
+
+#### Advanced Features
+
+On top of all of that, Redis even provides some very powerful out-of-the-box features:
+
+- **Lua Scripting**: Supports server-side scripting with Lua, enabling complex operations to be executed atomically.
+- **Pub/Sub Messaging**: Allows for message broadcasting to multiple clients, supporting real-time messaging and notifications. You can create whole event-based architectures around Redis.
+- **Modules**: Extend Redis functionality with custom modules, such as RedisGraph for graph database capabilities and RedisJSON for JSON document storage.
+
+Redis's robust feature set, combined with its high performance and flexibility, makes it a versatile tool for developers looking to build scalable and responsive applications.
+
+## Message Brokers and Streaming Platforms
+
+
+
+Message brokers and streaming platforms facilitate communication between different parts of a system, enabling efficient data exchange and processing. They are crucial for building scalable and resilient applications and they are the core of reactive architectures (also known as event-based architectures).
+
+### RabbitMQ
+
+RabbitMQ is an open-source message broker that implements the Advanced Message Queuing Protocol (AMQP). It supports multiple messaging protocols and can be deployed in distributed and federated configurations. RabbitMQ is ideal for use cases that require reliable message delivery, complex routing, and interoperability with other messaging systems. It is commonly used in financial systems, order processing, and other applications that need robust messaging capabilities.
+
+### Apache Kafka
+
+Apache Kafka is a distributed streaming platform designed for high-throughput, low-latency data processing. It excels at handling real-time data feeds, making it suitable for applications that require continuous data integration and processing. Kafka’s publish-subscribe messaging system is fault-tolerant and scalable, making it ideal for big data applications, real-time analytics, event sourcing, and log aggregation. Its ability to store streams of records in a fault-tolerant manner also makes it useful for building event-driven architectures and microservices.
+
+As backend developers, understanding how to take advantage of these message queues is critical to the development of scalable and resilient platforms. It is definitely a must-have skill and you need to master it.
+
+## Authentication and Authorization
+
+
+
+Authentication and authorization technologies are essential for securing applications, ensuring that users are who they claim to be and have the appropriate permissions to access resources.
+
+This space is filled with solutions and methodologies, so it’s not easy to pick one option here, however, these two are very common solutions used to implement both, authZ (authorization) and authN (authentication).
+
+### OAuth
+
+OAuth is an open standard for access delegation commonly used to grant websites or applications limited access to a user’s information without exposing their passwords. It is widely used in single sign-on (SSO) systems, enabling users to log in to multiple applications with a single set of credentials. OAuth is ideal for third-party applications that need access to user data, such as social media integrations and API access management.
+
+### JWT (JSON Web Tokens)
+
+JWT is a compact, URL-safe means of representing claims to be transferred between two parties. The claims in a JWT are encoded as a JSON object, which is used as the payload of a JSON Web Signature (JWS) structure or as the plaintext of a JSON Web Encryption (JWE) structure. JWTs are commonly used for authentication and authorization in web applications, providing a secure way to transmit information between parties. They are particularly useful in stateless authentication systems, where user state is not stored on the server (like when dealing with RESTful APIs).
+
+## CI/CD Pipelines
+
+
+
+CI/CD (Continuous Integration/Continuous Deployment) pipelines automate the process of code integration, testing, and deployment, enabling faster and more reliable software delivery. This is one of the key areas backend developers need to understand to avoid creating code that simply gets in the way of the deployment process.
+
+### GitHub Actions
+
+GitHub Actions is an integrated CI/CD service within GitHub repositories, allowing developers to automate build, test, and deployment workflows. It supports a wide range of actions and integrations, making it highly customizable and versatile for various development workflows.
+
+### CircleCI
+
+CircleCI is a continuous integration and delivery platform that automates the building, testing, and deployment of applications. It supports multiple backend languages and integrates with various version control systems, making it a popular choice for diverse development environments. CircleCI is known for its speed and ease of setup, providing robust tools for optimizing and monitoring CI/CD pipelines.
+
+### GitLab CI/CD
+
+GitLab CI/CD is an integrated part of the GitLab platform (similar to how GitHub actions are a part of GitHub), offering continuous integration, delivery, and deployment features within the GitLab ecosystem. It allows developers to manage their entire DevOps lifecycle in a single application, from planning and coding to monitoring and security. GitLab CI/CD is particularly useful for teams seeking a seamless and comprehensive CI/CD solution.
+
+### Jenkins
+
+If instead of a SaaS, you’re looking for a solution that you can potentially self-host, then you might want to look into Jenkins. Jenkins is an open-source automation server that provides hundreds of plugins to support building, deploying, and automating your software development process. It is highly extensible and can be integrated with a wide array of tools and technologies. Jenkins is ideal for complex, large-scale projects requiring a customizable and powerful CI/CD environment.
+
+## Monitoring and Logging
+
+
+
+Understanding how the systems that you develop behave and perform on a daily basis is crucial to launching a successful product. Here’s where monitoring and logging come into play. Monitoring and logging are crucial pieces of backend technology used for maintaining the health, performance, and security of applications. These tools help detect issues, analyze performance, and ensure system reliability.
+
+### ELK Stack (Elasticsearch, Logstash, Kibana)
+
+The ELK Stack is a set of tools for searching, analyzing, and visualizing log data in real time. Elasticsearch is a search and analytics engine, Logstash is a server-side data processing pipeline, and Kibana is a visualization tool. Together, they provide a powerful platform for centralized logging and monitoring, making them ideal for applications requiring detailed log analysis and real-time insights.
+
+### Grafana
+
+Grafana is an open-source platform for monitoring and observability that integrates with various data sources. It provides powerful visualizations, dashboards, and alerting capabilities, making it a popular choice for monitoring infrastructure and application performance. Grafana is particularly useful for teams needing a flexible and customizable monitoring solution.
+
+### Loki
+
+Loki is a log aggregation system designed to work with Grafana. It is optimized for cost-effective and scalable logging, making it suitable for applications with high log volumes. Loki simplifies log management by allowing developers to query logs using the same language as Grafana, providing seamless integration for comprehensive observability.
+
+### Prometheus
+
+Prometheus is an open-source monitoring and alerting toolkit designed for reliability and scalability. It collects and stores metrics as time series data, providing powerful querying language and alerting capabilities. Prometheus is ideal for monitoring applications and infrastructure, particularly in cloud-native and microservices environments, where dynamic and ephemeral resources are common.
+
+In the end, you might want to go with one or several of these options, the point is that you, as a developer, should be aware of them and what type of value they add to the project.
+
+## Conclusion
+
+As backend developers, focusing on a backend programming language and a backend framework is not going to be enough. The backend ecosystem is very rich, and there are many areas that are either directly or indirectly related to the daily tasks that a backend dev needs to work on.
+
+This is why you need to stay up-to-date and look at the trends that develop within each area to make sure you’re still working with and focusing on the right solutions.
+
+If you'd like more details on the type of backend development technologies you should be focusing on to excel at your role as a backend developer, check out our [Backend Developer roadmap](https://roadmap.sh/backend).
\ No newline at end of file
diff --git a/src/data/guides/devops-career-path.md b/src/data/guides/devops-career-path.md
index 8d38b5057..0e402e50c 100644
--- a/src/data/guides/devops-career-path.md
+++ b/src/data/guides/devops-career-path.md
@@ -132,7 +132,7 @@ As a DevOps professional, you can decide to go for any of these following DevOps
- Automation expert
- General DevOps engineer
- System engineer
-- DevOps erchitect
+- DevOps architect
- DevOps release manager
- DevSecOps engineer
- DevOps test engineer
diff --git a/src/data/projects/basic-html-website.md b/src/data/projects/basic-html-website.md
new file mode 100644
index 000000000..0895bac59
--- /dev/null
+++ b/src/data/projects/basic-html-website.md
@@ -0,0 +1,53 @@
+---
+title: 'Basic HTML Website'
+description: 'Create simple HTML only website with multiple pages.'
+isNew: false
+sort: 1
+difficulty: 'beginner'
+nature: 'HTML'
+skills:
+ - 'HTML'
+ - 'Layouts'
+ - 'semantic HTML'
+seo:
+ title: 'Basic HTML Website Project'
+ description: 'Create a simple HTML only website with multiple pages.'
+ keywords:
+ - 'basic html'
+ - 'html project idea'
+roadmapIds:
+ - 'frontend'
+---
+
+> Goal of this project is to teach you how to structure a website using HTML i.e. different sections of a website like header, footer, navigation, main content, sidebars etc. Do not style the website, only focus on the structure. Styling will be done in separate projects.
+
+In this project, you are required to create a simple HTML only website with multiple pages. The website should have following pages:
+
+- Homepage
+- Projects
+- Articles
+- Contact
+
+The website should have a navigation bar that should be present on all pages and link to all the pages.
+
+You are not required to style the website, you are only required to create the structure of the website using HTML. Goals of this project are:
+
+- Learn how to create multiple pages in a website.
+- Structure a website using HTML in a semantic way.
+- Structure in a way that you can easily add styles later.
+- Add SEO meta tags to the website.
+
+You can use the following mockup example to create the structure of the website (remember, you are not required to style the website, only focus on the structure that you can style later):
+
+
+
+Again, make sure that your submission includes the following:
+
+- Semantically correct HTML structure.
+- Multiple pages with a navigation bar.
+- SEO meta tags in the head of each page.
+- Contact page should have a form with fields like name, email, message etc.
+
+
+
+After completing this project, you will have a good understanding of how to structure a website using HTML, basic SEO meta tags, HTML tags, forms etc. You can now move on to the next project where you will learn how to style this website using CSS.
diff --git a/src/data/roadmaps/android/content/animations@Xn1VQ-xOT67ZfJJTM4r1p.md b/src/data/roadmaps/android/content/animations@Xn1VQ-xOT67ZfJJTM4r1p.md
index e69de29bb..1a34fef94 100644
--- a/src/data/roadmaps/android/content/animations@Xn1VQ-xOT67ZfJJTM4r1p.md
+++ b/src/data/roadmaps/android/content/animations@Xn1VQ-xOT67ZfJJTM4r1p.md
@@ -0,0 +1,8 @@
+# Animations
+
+`Animations` can add visual cues that notify users about what's going on in your app. They are especially useful when the UI changes state, such as when new content loads or new actions become available. Animations also add a polished look to your app, which gives it a higher quality look and feel.
+
+Visit the following resources to learn more:
+
+- [@official@Google developers: Animations](https://developer.android.com/develop/ui/views/animations/overview)
+- [@video@Google developers: Animations](https://www.youtube.com/watch?v=N_x7SV3I3P0)
diff --git a/src/data/roadmaps/android/content/constraint@3fFNMhQIuuh-NRzSXYpXO.md b/src/data/roadmaps/android/content/constraint@3fFNMhQIuuh-NRzSXYpXO.md
index e69de29bb..dbf4c9fc6 100644
--- a/src/data/roadmaps/android/content/constraint@3fFNMhQIuuh-NRzSXYpXO.md
+++ b/src/data/roadmaps/android/content/constraint@3fFNMhQIuuh-NRzSXYpXO.md
@@ -0,0 +1,8 @@
+# ConstraintLayout
+
+Lets you create large, complex layouts with a flat view hierarchy—no nested view groups. It's similar to `RelativeLayout` in that all views are laid out according to relationships between sibling views and the parent layout, but it's more flexible than RelativeLayout and easier to use. Its available on xml and jetpack compose.
+
+Visit the following resources to learn more:
+
+- [@official@Android developers: ConstraintLayout in xml](https://developer.android.com/develop/ui/views/layout/constraint-layout)
+- [@official@Android developers: ContraintLayout in compose](https://developer.android.com/develop/ui/compose/layouts/constraintlayout)
diff --git a/src/data/roadmaps/android/content/drawer@amTxz7mS98lkhOrNMJXG_.md b/src/data/roadmaps/android/content/drawer@amTxz7mS98lkhOrNMJXG_.md
index e69de29bb..12a1794bc 100644
--- a/src/data/roadmaps/android/content/drawer@amTxz7mS98lkhOrNMJXG_.md
+++ b/src/data/roadmaps/android/content/drawer@amTxz7mS98lkhOrNMJXG_.md
@@ -0,0 +1,8 @@
+# Drawer
+
+The **Navigation Drawer** in Android is a sliding menu from the left that simplifies navigation between important app links. It opens by sliding or via an icon in the `ActionBar`. It’s an overlay panel that replaces a screen dedicated to displaying options.
+
+Visit the following resources to learn more:
+
+- [@official@Android developers: DrawerLayout](https://developer.android.com/reference/androidx/drawerlayout/widget/DrawerLayout)
+- [@article@Navigate Drawer Tutorial](https://www.digitalocean.com/community/tutorials/android-navigation-drawer-example-tutorial)
diff --git a/src/data/roadmaps/android/content/listview@EzLjX4iRT7AxkAOsJYnSU.md b/src/data/roadmaps/android/content/listview@EzLjX4iRT7AxkAOsJYnSU.md
index e69de29bb..e217c232d 100644
--- a/src/data/roadmaps/android/content/listview@EzLjX4iRT7AxkAOsJYnSU.md
+++ b/src/data/roadmaps/android/content/listview@EzLjX4iRT7AxkAOsJYnSU.md
@@ -0,0 +1,9 @@
+# ListView
+
+Displays a vertically-scrollable collection of views, where each view is positioned immediatelybelow the previous view in the list.
+
+For a more modern, flexible, and performant approach to displaying lists, use `RecyclerView`.
+
+Visit the following resources to learn more:
+
+- [@official@Android developers: ListView](https://developer.android.com/reference/android/widget/ListView)
diff --git a/src/data/roadmaps/angular/angular.json b/src/data/roadmaps/angular/angular.json
index fdd4468d3..a09e1960c 100644
--- a/src/data/roadmaps/angular/angular.json
+++ b/src/data/roadmaps/angular/angular.json
@@ -2579,39 +2579,6 @@
"focusable": true,
"resizing": false
},
- {
- "id": "Wc2ybRw43uamEtno0FpDv",
- "type": "subtopic",
- "position": {
- "x": -99.73327447982547,
- "y": 957.2304293708296
- },
- "selected": false,
- "data": {
- "label": "Template Ref Vars",
- "style": {
- "fontSize": 17,
- "justifyContent": "flex-start",
- "textAlign": "center"
- },
- "oldId": "nyDry6ZWyEUuTq4pw-lU3"
- },
- "zIndex": 999,
- "width": 225,
- "height": 49,
- "style": {
- "width": 225,
- "height": 49
- },
- "positionAbsolute": {
- "x": -99.73327447982547,
- "y": 957.2304293708296
- },
- "dragging": false,
- "resizing": false,
- "selectable": true,
- "focusable": true
- },
{
"id": "VsU6713jeIjAOEZnF6gWx",
"type": "subtopic",
diff --git a/src/data/roadmaps/angular/content/build-environments@Ax-s_xw3FO3Ocv-AnLbQD.md b/src/data/roadmaps/angular/content/build-environments@Ax-s_xw3FO3Ocv-AnLbQD.md
index 1c3e193ba..45881e352 100644
--- a/src/data/roadmaps/angular/content/build-environments@Ax-s_xw3FO3Ocv-AnLbQD.md
+++ b/src/data/roadmaps/angular/content/build-environments@Ax-s_xw3FO3Ocv-AnLbQD.md
@@ -1 +1,8 @@
-# Build Environments
\ No newline at end of file
+# Build Environments
+
+You can define different named build configurations for your project, such as `development` and `production`, with different defaults. Each named configuration can have defaults for any of the options that apply to the various builder targets, such as `build`, `serve`, and `test`. The Angular CLI can replace files for each environment if you pass a `--configuration` flag with the named configuration when running a CLI command.
+
+Visit the following resources to learn more:
+
+- [@official@Angular Official Docs - Build environments](https://angular.dev/tools/cli/environments#using-environment-specific-variables-in-your-app)
+- [@article@Building an Angular application in various environments using Angular CLI and server](https://medium.com/yavar/building-an-angular-application-in-various-environments-using-angular-cli-and-server-18f94067154b)
\ No newline at end of file
diff --git a/src/data/roadmaps/angular/content/case@cHC2MH50CbUSMRZV4QGJI.md b/src/data/roadmaps/angular/content/case@cHC2MH50CbUSMRZV4QGJI.md
index 5a719d592..8c5a7bb4a 100644
--- a/src/data/roadmaps/angular/content/case@cHC2MH50CbUSMRZV4QGJI.md
+++ b/src/data/roadmaps/angular/content/case@cHC2MH50CbUSMRZV4QGJI.md
@@ -1 +1,8 @@
-# @case
\ No newline at end of file
+# @case
+
+If no `@case` matches the `@switch` condition and there is no `@default` block, nothing is shown. Otherwise, the content inside the `@case` that matches the condition will be displayed.
+
+Visit the following resources to learn more:
+
+- [@official@Angular Official Docs - @switch](https://angular.dev/guide/templates/control-flow#switch-block---selection)
+- [@article@Angular @switch: Complete Guide](https://blog.angular-university.io/angular-switch/)
\ No newline at end of file
diff --git a/src/data/roadmaps/angular/content/cli-builders@TeWEy9I-hU6SH02Sy2S2S.md b/src/data/roadmaps/angular/content/cli-builders@TeWEy9I-hU6SH02Sy2S2S.md
index abe74fab5..22d2a75bb 100644
--- a/src/data/roadmaps/angular/content/cli-builders@TeWEy9I-hU6SH02Sy2S2S.md
+++ b/src/data/roadmaps/angular/content/cli-builders@TeWEy9I-hU6SH02Sy2S2S.md
@@ -1 +1,9 @@
-# CLI Builders
\ No newline at end of file
+# CLI Builders
+
+A number of Angular CLI commands run a complex process on your code, such as building, testing, or serving your application. The commands use an internal tool called `Architect` to run CLI builders, which invoke another tool (bundler, test runner, server) to accomplish the desired task. Custom builders can perform an entirely new task or to change which third-party tool is used by an existing command.
+
+Visit the following resources to learn more:
+
+- [@official@Angular Official Docs - CLI Builders](https://angular.dev/tools/cli/cli-builder)
+- [@video@Angular Builders – Creating Custom Builder from Scratch](https://www.youtube.com/watch?v=QbDkDLnXAZE)
+- [@opensource@Angular Builders](https://github.com/just-jeb/angular-builders)
\ No newline at end of file
diff --git a/src/data/roadmaps/angular/content/creating-libraries@A1mYMg7cbcj6p_VkDf-Tz.md b/src/data/roadmaps/angular/content/creating-libraries@A1mYMg7cbcj6p_VkDf-Tz.md
index a4c6d8e3c..30e0670b1 100644
--- a/src/data/roadmaps/angular/content/creating-libraries@A1mYMg7cbcj6p_VkDf-Tz.md
+++ b/src/data/roadmaps/angular/content/creating-libraries@A1mYMg7cbcj6p_VkDf-Tz.md
@@ -1 +1,9 @@
-# Creating Libraries
\ No newline at end of file
+# Creating Libraries
+
+If you have developed features that are suitable for reuse, you can create your own libraries. These libraries can be used locally in your workspace, or you can publish them as npm packages to share with other projects or other Angular developers. Putting code into a separate library is more complex than simply putting everything in one application. It requires more of an investment in time and thought for managing, maintaining, and updating the library. This complexity can pay off when the library is being used in multiple applications.
+
+Visit the following resources to learn more:
+
+- [@official@Angular Official Docs - Creating Libraries](https://angular.dev/tools/libraries/creating-libraries)
+- [@official@Angular Official Docs - File Structure: Library project files](https://angular.dev/reference/configs/file-structure#library-project-files)
+- [@opensource@NG Packagr](https://github.com/ng-packagr/ng-packagr)
\ No newline at end of file
diff --git a/src/data/roadmaps/angular/content/cross-site-request-forgery@Z1DZBbFI4oU6-KQg3wqMm.md b/src/data/roadmaps/angular/content/cross-site-request-forgery@Z1DZBbFI4oU6-KQg3wqMm.md
index 2c8a31f90..bb2e5f4f0 100644
--- a/src/data/roadmaps/angular/content/cross-site-request-forgery@Z1DZBbFI4oU6-KQg3wqMm.md
+++ b/src/data/roadmaps/angular/content/cross-site-request-forgery@Z1DZBbFI4oU6-KQg3wqMm.md
@@ -1 +1,10 @@
-# Cross-site Request Forgery
\ No newline at end of file
+# Cross-site Request Forgery
+
+Cross-site request forgery, also known as one-click attack or session riding and abbreviated as CSRF or XSRF, is a type of malicious exploit of a website or web application where unauthorized commands are submitted from a user that the web application trusts. There are many ways in which a malicious website can transmit such commands; specially-crafted image tags, hidden forms, and JavaScript fetch or XMLHttpRequests, for example, can all work without the user's interaction or knowledge. Unlike cross-site scripting (XSS), which exploits the trust a user has for a particular site, CSRF exploits the trust that a site has in a user's browser. In a CSRF attack, an innocent end user is tricked by an attacker into submitting a web request that they did not intend. This may cause actions to be performed on the website that can include inadvertent client or server data leakage, change of session state, or manipulation of an end user's account. Angular provides built-in protection against CSRF attacks through the `HttpClientXsrfModule` module. This module automatically adds a token to outgoing requests and validates it on the server side.
+
+Visit the following resources to learn more:
+
+- [@official@Angular Official Docs - Cross Site Request Forgery](https://angular.dev/best-practices/security#cross-site-request-forgery)
+- [@official@HttpClientXsrfModule](https://angular.dev/api/common/http/HttpClientXsrfModule)
+- [@video@Configure the CSRF Protection With Spring Security 6 and Angular](https://www.youtube.com/watch?v=tgjLsEmxcuY)
+- [@video@Angular security - CSRF prevention using Double Submit Cookie](https://www.youtube.com/watch?v=lZfF4MOTeNM)
diff --git a/src/data/roadmaps/angular/content/cross-site-script-inclusion@zd7YJGlcMFNFbsKUiW_XC.md b/src/data/roadmaps/angular/content/cross-site-script-inclusion@zd7YJGlcMFNFbsKUiW_XC.md
index 535baaa7d..47afc1709 100644
--- a/src/data/roadmaps/angular/content/cross-site-script-inclusion@zd7YJGlcMFNFbsKUiW_XC.md
+++ b/src/data/roadmaps/angular/content/cross-site-script-inclusion@zd7YJGlcMFNFbsKUiW_XC.md
@@ -1 +1,9 @@
-# Cross-site Script Inclusion
\ No newline at end of file
+# Cross-site Script Inclusion
+
+Cross-site script inclusion, also known as JSON vulnerability, can allow an attacker's website to read data from a JSON API. The attack works on older browsers by overriding built-in JavaScript object constructors, and then including an API URL using a `