The Best Microservices courses for beginners to learn Microservices in 2021.

Information is the new definition for Gold. It is gold for organizations that can tackle the force of advancements and use it while changing their plans of action into the computerized age and become considerably more information-driven. It is an astounding excursion energized by new advances, yet we need to recall that information without anyone else is only one piece of the condition.

Up to this point, numerous venture-level applications were planned, created, and kept up as one monster solid application. With a once in a year programming discharge cycle, perhaps multiple times in a year. Each little update needed to construct, test, and send all application modules as one bundle.

Microservices is the new inventive improvement style, previously being utilized by organizations like Netflix, Facebook, Amazon, and others. Miniature administrations are the structure blocks for making cloud-local applications, and subsequently, we will see more organizations following this heading.

Microservices is a significant engineering design in the product business and having an outline of this engineering is-and what it isn't-is basic as a beginning stage to assessing this model. It is the main answer for building and scaling out applications that are planned to develop.

The interest for serverless is speeding up as associations hope to scale all the more rapidly and effectively. With the expansion in cloud appropriation, Microservices inside the serverless stack are getting more well known with quicker arrangements and more prominent adaptability.

Disclosure: Coursesity is supported by the learner's community. We may earn an affiliate commission when you make a purchase via links on Coursesity.

Top Microservices Courses List

  1. Microservices Foundations Online Class

  2. Master Microservices with Spring Boot and Spring Cloud

  3. Microservices: Design Patterns Online Class

  4. Microservices with Node JS and React

  5. Microservices: The Big Picture

  6. Microservices with Spring Cloud

  7. Building Microservice Platforms with TARS

  8. Spring Boot Microservices and Spring Cloud

  9. Learn the Microservices overall Architecture, Building Blocks, Key Adv

  10. Microservices DevOps

  11. Build Microservices with Spring Boot, React and Spring Cloud

  12. Microservices, Serverless, OpenShift

1. Microservices Foundations Online Class

Explore the basic concepts of microservices. Get the foundational knowledge you need to determine if this architectural model is the right fit for you and your team.

Course rating: 208,575 total enrollments

Certificate: Certificate on completion

The course includes:

  • History of service-based architectures
  • The monolithic application
  • Services-oriented architecture
  • Microservices: The new kid on the block
  • Microservices: Solver of problems but not the silver bullet
  • Microservices and cloud-native
  • Microservices Core Concepts
  • Microservices Advanced Concepts
  • Asynchronous communications
  • Logging and tracing in a microservices architecture
  • Continuous delivery as a requirement
  • Hybrid architectures: Hierarchy and service-based
  • Making Architecture Choices
  • Design considerations
  • The tradeoffs
  • An argument for edge services
  • Embracing DevOps

This course covers the basic concepts of microservices, to help you determine if this architectural model is the right fit for you and your team. You will start the course by briefly discussing how microservices fit into the history of software architecture and going into some of the other notable patterns that have emerged in recent years.

The course then helps to familiarize you with some core concepts of microservices, including bounded contexts and the API layer. It also goes over some of the more advanced areas of the architecture, as well as the importance of embracing a DevOps culture should you choose to move to microservices.

You can take Microservices Foundations Online Class Certificate Course on LinkedIn.

2. Master Microservices with Spring Boot and Spring Cloud

Go from Restful Web Services ( REST API ) to Microservices - Java, Spring Boot, Spring Cloud, Docker, and Kubernetes.

Course rating: 4.4 out of 5.0 ( 27,923 Ratings total)

Duration: 19 h 5 m

Certificate: Certificate on completion

In this course, you will learn how to:

  • develop and design RESTful web services with Spring Boot.
  • develop MICROSERVICES with Spring Boot and Spring Cloud.
  • orchestrate microservices with KUBERNETES.
  • create containers for microservices with DOCKER.
  • implement Exception Handling, Validation, HATEOAS, and filtering for RESTful Web Services.
  • implement client-side load balancing (Ribbon), Dynamic scaling(Eureka Naming Server), and an API Gateway (Zuul).
  • set up Centralized Microservices Configuration with Spring Cloud Config Server.
  • implement Distributed tracing for microservices with Spring Cloud Sleuth and Zipkin.
  • implement Fault Tolerance for microservices with Hystrix.
  • version your RESTful Web Services.
  • monitor RESTful Services with Spring Boot Actuator.
  • document RESTful Web Services with Swagger.
  • understand the best practices in designing RESTful web services.
  • use Spring Cloud Bus to exchange messages about Configuration updates.
  • simplify communication with other Microservices using Feign REST Client.

The course includes:

  • Initializing a RESTful Services Project with Spring Boot
  • Understanding the RESTful Services we would create in this course
  • Creating a Hello World Service
  • Enhancing the Hello World Service to return a Bean
  • Quick Review of Spring Boot Auto Configuration and Dispatcher Servlet - What's happening in the background?
  • Enhancing the Hello World Service with a Path Variable
  • Creating User Bean and User Service
  • Implementing GET Methods for User Resource
  • Implementing POST Method to create User Resource
  • Enhancing POST Method to return correct HTTP Status Code and Location URI
  • Implementing Exception Handling - 404 Resource Not Found
  • Implementing Generic Exception Handling for all Resources
  • Exercise: User Post Resource and Exception Handling
  • Implementing DELETE Method to delete a User Resource
  • Implementing Validations for RESTful Services
  • Implementing HATEOAS for RESTful Services
  • Overview of Advanced RESTful Service Features
  • Internationalization for RESTful Services
  • Content Negotiation - Implementing Support for XML
  • Configuring Auto Generation of Swagger Documentation
  • Introduction to Swagger Documentation Format
  • Enhancing Swagger Documentation with Custom Annotations
  • Monitoring APIs with Spring Boot Actuator
  • Implementing Static Filtering for RESTful Service
  • Implementing Dynamic Filtering for RESTful Service
  • Versioning RESTful Services - Basic Approach with URIs
  • Versioning RESTful Services - Header and Content Negotiation Approaches
  • Implementing Basic Authentication with Spring Security
  • Overview of Connecting RESTful Service to JPA
  • Creating User Entity and some test data
  • Updating GET methods on User Resource to use JPA
  • Updating POST and DELETE methods on User Resource to use JPA
  • Creating Post Entity and Many to One Relationship with User Entity
  • Implementing a GET service to retrieve all Posts of a User
  • Implementing a POST service to create a Post for a User
  • Richardson Maturity Model
  • RESTful Services Best Practices
  • Introduction to Limits Microservice and Spring Cloud Config Server
  • Setting up Limits Microservice
  • Creating a hardcoded limits service
  • Enhance limits service to pick up configuration from application properties
  • Setting up Spring Cloud Config Server
  • Installing Git
  • Creating Local Git Repository
  • Connect Spring Cloud Config Server to Local Git Repository
  • Configuration for Multiple Environments in Git Repository
  • Connect Limits Service to Spring Cloud Config Server
  • Configuring Profiles for Limits Service
  • A review of Spring Cloud Config Server
  • Introduction to Currency Conversion and Currency Exchange Microservices
  • Setting up Currency Exchange Microservice
  • Create a simple hardcoded currency exchange service
  • Setting up Dynamic Port in the Response
  • Configure JPA and Initialized Data
  • Create a JPA Repository
  • Setting up Currency Conversion Microservice
  • Creating a service for currency conversion
  • Invoking Currency Exchange Microservice from Currency Conversion Microservice
  • Using Feign REST Client for Service Invocation
  • Setting up client-side load balancing with Ribbon
  • Running client-side load balancing with Ribbon
  • Understand the need for a Naming Server
  • Setting up Eureka Naming Server
  • Connecting Currency Conversion Microservice to Eureka
  • Connecting Currency Exchange Microservice to Eureka
  • Distributing calls using Eureka and Ribbon
  • A review of implementing Eureka, Ribbon, and Feign
  • Introduction to API Gateways
  • Setting up Zuul API Gateway
  • Implementing Zuul Logging Filter
  • Executing a request through Zuul API Gateway
  • Setting up Zuul API Gateway between microservice invocations
  • Introduction to Distributed Tracing
  • Implementing Spring Cloud Sleuth
  • Introduction to Distributed Tracing with Zipkin
  • Installing Rabbit MQ
  • Setting up Distributed Tracing with Zipkin
  • Connecting microservices to Zipkin
  • Using Zipkin UI Dashboard to trace requests
  • Understanding the need for Spring Cloud Bus
  • Implementing Spring Cloud Bus
  • Fault Tolerance with Hystrix

There are two parts to this course - RESTful web services and Microservices

In the first part of the course, you will learn the basics of RESTful web services developing resources for a social media application. You will learn to implement these resources with multiple features - versioning, exception handling, documentation (Swagger), basic authentication (Spring Security), filtering, and HATEOAS. You will learn the best practices in designing RESTful web services.

In this part of the course, you will be using Spring (Dependency Management), Spring MVC (or Spring REST), Spring Boot, Spring Security (Authentication and Authorization), Spring Boot Actuator (Monitoring), Swagger (Documentation), Maven (dependencies management), Eclipse (IDE), Postman (REST Services Client) and Tomcat Embedded Web Server. The course will help you set up each one of these.

In the second part of the course, you will learn the basics of Microservices. You will understand how to implement microservices using Spring Cloud.

In this part of the course, you will learn to establish communication between microservices, enable load balancing, scaling up and down of microservices. You will also learn to centralize the configuration of microservices with Spring Cloud Config Server.

You will implement Eureka Naming Server and Distributed tracing with Spring Cloud Sleuth and Zipkin. You will create fault-tolerant microservices with Zipkin.

In the third part of the course, you will learn the basics of Docker. You will understand how to build containers for microservices built using Docker and Spring Cloud.

Finally, you will learn the basics of Kubernetes. You will understand how to orchestrate microservices with Kubernetes.

You can take Master Microservices with Spring Boot and Spring Cloud Certificate Course on Udemy.

3. Microservices: Design Patterns Online Class

Learn how to use design patterns to efficiently solve the most common problems you'll encounter when building and operating microservices.

Course rating: 27,789 total enrollments

Certificate: Certificate on completion

The course includes:

  • Decomposition Patterns
  • Decomposition of a system
  • Domain-based microservices
  • Business process-based microservices
  • Atomic transaction-based microservices
  • Strangler pattern
  • Sidecar pattern
  • Integration Patterns
  • Gateway pattern
  • Process aggregator pattern
  • Edge pattern
  • Data Patterns
  • Single service database
  • Shared service database
  • Command Query Responsibility Segregation
  • Asynchronous eventing
  • Operational Patterns
  • Log aggregation patterns
  • Metrics aggregation patterns
  • Tracing patterns
  • External configuration
  • Service discovery

In this course, get up to speed with over 15 different design patterns you can leverage when building and operating microservices, as well as the common problems they can help you remedy.

The course goes over decomposition, integration, data, and operational patterns, tying each pattern to the problem it solves. Learn about the API gateway pattern that can prevent chaos by providing a buffer between underlying services and client needs, the sidecar pattern that allows you to offload processing of some kind to a separate module, and much more.

You can take Microservices: Design Patterns Online Class Certificate Course on LinkedIn.

4. Microservices with Node JS and React

Build, deploy, and scale an E-Commerce app using Microservices built with Node, React, Docker and Kubernetes.

Course rating: 4.8 out of 5.0 ( 7,154 Ratings total)

Duration : 54 h

Certificate: Certificate on completion

In this course, you will learn how to:

  • architect large, scalable apps using a collection of microservices.
  • deploy a multi-service app to the cloud with Docker and Kubernetes.
  • solve concurrency issues in a distributed systems environment.
  • leverage your Javascript skills to build a complex web app.
  • build a Server-Side Rendered React App to render data from your microservices.
  • understand how enterprise companies design their infrastructure.
  • share reusable code between multiple Express servers using custom NPM packages.
  • practice patterns to create scalable microservices for a variety of app domains.
  • build a Server-Side-Rendered React app using Hooks and Next JS.
  • write a custom implementation of an event bus.
  • run a development environment through a cloud provider optionally.
  • guarantee consistently structured responses from your different APIs.
  • see best practices in communication between different services.
  • configure and scale your services using Kubernetes Deployments.
  • document and enforce structure constraints on events shared across microservices.
  • limit access to your APIs using JWT-based authentication.

You can take Microservices with Node JS and React Certificate Course on Udemy.

5. Microservices: The Big Picture

Microservices are quickly being adopted by companies worldwide. This course teaches you the basics of microservice architectures from a 10,000-foot high view.

Course rating: 4.5 out of 5.0 ( 575 Ratings total)

Certificate: Certificate on completion

The course includes:

  • What Are Microservices?
  • Software Development Lifecycle
  • What Are Microservices?
  • Microservices Elements
  • Building a Monolith
  • Building Microservices
  • Organization
  • Data Store
  • User Interface
  • Services
  • Distributed Services
  • Security
  • Scalability and Availability
  • Monitoring
  • Deployment
  • Revisiting the Microservices Elements
  • Is Microservices Right for Your Organization?
  • Challenges
  • Business Concerns
  • Technical Concerns
  • Production Concerns

In this course, Microservices: The Big Picture, you will learn exactly what microservices are. First, you will become familiar with the elements of a microservice.

Then, you will explore design patterns, terminology, and functional concepts. Finally, you will see the pros and cons of microservices architecture in a business as well as technical points of view.

When you’re finished with this course you’ll have enough knowledge to decide whether to use microservices in your future project.

You can take Microservices: The Big Picture Certificate Course on Pluralsight.

6. Microservices with Spring Cloud

A deep dive into the Microservice architectural style, and how to implement it with Spring technologies.

Course rating: 4.4 out of 5.0 ( 6,658 Ratings total)

Duration: 4 h 5 m

Certificate: Certificate on completion

In this course, you will learn:

  • centralized, versioned configuration management using Spring Cloud Config.
  • dynamic configuration updates with Spring Cloud Bus.
  • service discovery with Spring Cloud Eureka.
  • client-side load balancing with Ribbon.
  • declarative REST Clients with Feign.
  • how to articulate the Microservices architectural style; its advantages and disadvantages.
  • how to build simple Spring Boot applications utilizing web interfaces, REST interfaces, Spring Data, and HATEOAS.
  • how to build Microservice applications utilizing the different Spring Cloud sub-projects, including Config Server & Bus, Eureka, Ribbon, Feign, and Hystrix.
  • software circuit breakers with Hystrix.

This course provides a good, solid introduction to the topic of the Microservices architectural style, and combines this with practical experience gained by working through the exercises featuring Spring Cloud.

Along the way, this course will provide a brief introduction to Spring Boot and Spring Data (enough to get you familiar with these technologies if you have not been immersed in them already).

Here, you will gain familiarity with Spring Boot, and you’ll see how to use it to build web interfaces, REST interfaces, and how to use Spring Data and Spring Data REST.

Also, you will gain the ability to build microservice-based applications utilizing Spring Cloud technologies.

You can take Microservices with Spring Cloud Certificate Course on Udemy.

7. Building Microservice Platforms with TARS

Are you interested in microservices? Don’t miss out on TARS! Get an in-depth primer on the powerful TARS framework for building your microservice platform.

Duration: 1176 h

Certificate: Certificate on completion

In this course, you will learn how to:

  • explain the concepts of the monolith, microservices, service mesh, and serverless, and understand how their differences translate into the different approaches for software development.
  • describe the components and characteristics of the TARS framework.
  • install and operate TARS in Docker, Kubernetes, or from source code.
  • create a microservices application using the TARS framework.
  • maintain or scale up microservices applications in TARS.
  • understand the features that make TARS a preferred solution for enterprises across different industries.

The course includes:

  • Introduction to Microservices and TARS
  • TARS Environment Setup
  • Fundamentals of TARS

This course is an introduction to microservices and the TARS framework for beginners. TARS is a new generation distributed microservice applications framework designed to support multiple programming languages, including C++, Golang, Java, Node.js, PHP, and Python, which allows developers and enterprises to quickly build stable and reliable applications that run at scale.

This course will show you why more and more developers and companies have chosen TARS to build their services. It is designed for engineers working in microservices, as well enterprise managers interested in exploring internal technical architectures, especially working for digital transmission in the traditional industry.

In addition, anyone interested in software architecture will benefit from this course. You will learn how to efficiently develop microservices programs using different programming languages and quickly deploy the corresponding services into applications.

Upon completion, you will wield a powerful skill for understanding microservices architecture and should be able to quickly build stable and reliable applications based on TARS.

You can take Building Microservice Platforms with TARS Certificate Course on Edx.

8. Spring Boot Microservices and Spring Cloud

Learn to build RESTful Microservices with Spring Boot and Spring Cloud.

Course rating: 4.5 out of 5.0 ( 4,231 Ratings total)

Duration: 18 h 5 m

Certificate: Certificate on completion

In this course, you will learn how to:

  • build and run RESTful Microservices.
  • implement User Authentication.
  • understand Eureka Discovery Service.
  • implement User Authorization with Spring Security and JWT.
  • understand Spring Cloud API Gateway.
  • use JPA to persist data into a database.
  • understand Cloud Cloud Config Server.
  • install MySQL Server and persist data into MySQL.
  • understand Spring Cloud Bus and Rabbit MQ.
  • understand H2 in-memory database and H2 Console.
  • understand Spring Boot Actuator.
  • use HTTP Postman.
  • use Spring Security.
  • use Spring Initializer.
  • perform distributed Tracing with Sleuth and Zipkin.
  • use Spring Tool Suite.
  • understand centralized Logging with ELK Stack(Logstash, Elasticsearch, Kibana).
  • run Microservices in Docker Containers.

The course includes:

  • RESTful Microservices
  • Eureka Discovery Service
  • Zuul API Gateway
  • Spring Cloud API Gateway
  • Load Balancer
  • Spring Cloud Config Server
  • Spring Cloud Bus and Rabbit MQ
  • Spring Boot Actuator
  • User Authentication(Login) and,
  • User Authorization(Registration)
  • Spring Security and JWT
  • Spring Data JPA to store user details in a database
  • H2 in-memory database and a database console
  • MySQL database server
  • Postman HTTP Client
  • Spring Tool Suite
  • Spring Initializer
  • Trace HTTP Requests with Spring Cloud Sleuth and Zipkin(Distributed tracing)
  • Aggregate log files in one place(Centralized logging) with ELK stack(Logstash Elasticsearch, Kibana).
  • Starting up AWS EC2 Linux machine
  • Installing Docker
  • Creating Docker images
  • Running Microservices in Docker containers on multiple EC2 Linux machines in Amazon AWS Cloud

This course will guide you step-by-step through basics and will help you create and run RESTful Microservices from scratch. You will learn how to run Microservices on your own developer's machine as well as in Docker Containers on AWS EC2 Linux machines.

By the end of this course, you will have your own RESTful Spring Boot Microservices built and running in Spring Cloud.

You can take Spring Boot Microservices and Spring Cloud Certificate Course on Udemy.

9. Learn the Microservices overall Architecture, Building Blocks, Key Adv

A Beginner's Guide to a Microservices Architecture

Course rating: 3.2 out of 5.0 ( 49 Ratings total)Duration: 2 h

Certificate: Certificate on completion

In this course, you will learn:

  • challenges of the traditional monolithic software development.
  • main building blocks of a single micro-service.
  • cloud-native application.
  • key advantages of microservices.

The course includes:

  • Monolithic Applications
  • The Microservices Revolution
  • The Concept of a Microservices Architecture (MSA)
  • What are the Key Benefits of Microservices?

This course will provide you a solid theoretical understanding of the micro-services concept. The challenges with the old-school development style The industry definition of micro-services and the building blocks of a single micro-service

Then, you will move on to the macro level and talk about the concept of a microservices architecture. What are the key benefits of this approach? Review some interesting case studies Would you like to join the Microservices Revolution?

You can take Learn the Microservices overall Architecture, Building Blocks, Key Adv Certificate Course on Eduonix.

10. Microservices DevOps

In this course, you'll learn about several key principles and patterns that will enable you to successfully deploy, monitor, and manage your microservice applications leading to more scalable and more resilient applications and infrastructure.

Course rating: 4.0 out of 5.0 ( 59 Ratings total)

Certificate: Certificate on completion

The course includes:

  • Implementing Continuous Deployment
  • The Scenario
  • Introducing DevOps
  • The 5 Essentials
  • Deploying Microservices
  • Deployment Patterns
  • Serverless Functions
  • Monitoring Microservice Performance
  • Why Do We Monitor?
  • What to Monitor?
  • Centralized Logging
  • Managing Microservice Failure
  • Module Introduction
  • Understanding Service Failure
  • The Circuit Breaker Pattern
  • Health Monitoring
  • Demo: Health Monitoring
  • Demo: Alerts

In this course, Microservices DevOps you will learn how to deploy and monitor your microservices. First, you will learn how to configure continuous deployment. Next, you will explore the key deployment patterns that you can use before discovering how to monitor your Microservices.

Finally, you will discover how to manage microservice failure. When you are finished with this course, you will have a foundational knowledge of Microservice DevOps that will enable you to solve your microservice deployment and monitoring challenges.

You can take Microservices DevOps Certificate Course on Pluralsight.

11. React + Spring Boot Microservices and Spring Cloud

Learn to create microservices using Spring Boot, React, Spring Cloud, Eureka Discovery, Zuul Gateway, MySQL, and Liquibase. Sign up for this online tutorial now!

Course rating: 4.5 out of 5.0 ( 292 Ratings total)

Duration: 5 h

Certificate: Certificate on completion

In this course, you will learn about:

  • Eureka Discovery: to connect to other services.
  • Spring Zuul Gateway: gate for microservices.
  • React User Interface for microservices.
  • MySQL
  • Spring Security

Learn to create microservices using Spring Boot, React, Spring Cloud, Eureka Discovery, Zuul Gateway, MySQL, and Liquibase.

The course uses Spring Boot which will provide a simpler and faster way to set up, configure, and run rest API applications with Spring boot, Model View Controller structure will be implemented.

Also, the data will be presented to the client as an API call so Spring Rest Controller will be used to handle it. You will map your database tables to objects with hibernate. so the course will provide object-relational mapping with hibernate.

For database migration, the course will use Liquibase. In liquibase, it will define your database changes and spring will handle it on initialization.

You can take React + Spring Boot Microservices and Spring Cloud Certificate Course on Eduonix.

12. Microservices, Serverless, OpenShift

Learn about Microservices architecture and Serverless computing. Understand their benefits and the process for deployment. Practice using multiple tools in hands-on labs. Create a serverless web application and deploy it as a Microservice on OpenShift and as static files on Cloud Object Storage.

Duration: 672 h

Certificate: Certificate on completion

In this course, you will learn how to:

  • summarize the fundamentals of Microservices, their advantages, and contrast with monolithic architectures.
  • explain the capabilities of service mesh including Istio, why it is useful, and how it alleviates challenges with Microservices.
  • explain the process for deploying Microservices on OpenShift.
  • describe Function as Service capabilities and benefits.
  • describe Serverless Computing and its increasing importance for developers in Cloud Native development.
  • identify the attributes of serverless.
  • build a serverless web application and deploy as a microservice on Red Hat OpenShift and as static files on Cloud Object Storage.

The course includes:

Module 1: Introduction to Microservices

  • Twelve-Factor App
  • What are Microservices
  • Advantages of Microservices
  • Microservices and IBM Cloud
  • Lab: Modernize App Using Microservices

Module 2: Introduction to Serverless

  • What is Serverless?
  • Serverless Pros and Cons
  • What is Function as a Service?
  • The Serverless Stack
  • Comparing the FaaS Model
  • Use Cases and Reference Architecture
  • Serverless and IBM Cloud
  • Lab: Hello World with Serverless

Module 3: ORM: Microservices w/ Serverless

  • Create and Invoke Actions – Part 1
  • Create and Invoke Actions – Part 2
  • Manage Action with Packages
  • Connect Actions to Event Sources
  • Expose Actions as APIs
  • IBM Cloud Code Engine
  • Lab: Serverless Web Application and API

Module 4: OpenShift Essentials/Working with OpenShift and Istio

  • OpenShift Recap
  • Service Mesh and Istio
  • Istio and Microservices
  • How to Create and Deploy Microservices w/ OpenShift and Istio
  • Red Hat Marketplace
  • Lab: Deploying Microservices w/ OpenShift and Istio

This intermediate-level course begins with a refresher on Microservices and the advantages of using a Microservices architecture. You will then gain an understanding of how serverless benefits developers when to use serverless programming and serverless deployment models and be introduced to serverless technologies.

You will discover how serverless supports continuous integration and continuous delivery (CI/CD), and microservices integration. This course will give you the experience to create and deploy Microservices using OpenShift and Istio.

For your final project, you will put into practice your serverless and microservices skills and create a real-world serverless web application using OpenShift and Cloud Object Storage.

You can take Microservices, Serverless, OpenShift Certificate Course on Edx.


Hey! If you have made it this far then certainly you are willing to learn more and here at Coursesity, it is our duty to enlighten people with knowledge on topics they are willing to learn. Here are some more topics that we think will be interesting for you!