Spring Boot Reviews

I am still currently working with Spring Boot and Java.

We use Spring Boot for microservices. Because a big project has multiple modules, if one module or any service is down, the whole project is not affected. There is a functionality of microservices where we can divide the whole project into different microservices. If one service is working and there are any issues in that particular service, we can fix it while the remaining services continue to work fine.

I am not using the Actuator for monitoring in Spring Boot. However, Spring Boot already has accurate monitoring available. I rely on its features for application health and logging. We maintain logs for any bugs or issues in the application.

With this accurate monitoring, I see numerous benefits in application management. If an application is running, we monitor memory usage, JVM, CPU usage, and how many requests are handled at the same time for load balancing. We can see metrics that inform us about resource allocation, allowing us to adjust CPU and RAM as needed.

From working with Spring Boot, I have seen many benefits. For instance, in terms of monitoring, we can conduct real-time health checks on whether any service is up or down. We track CPU performance, garbage collection, and the number of simultaneous requests and response times. Another best feature is its security and configurability, which makes it easy to integrate any third-party applications.

I am a developer who previously worked on AdMob and switched to Spring Boot. The project involves banking and hospital systems. They asked if I would work with them, so they changed the platform technology, and I needed to work on Spring Boot and Java technology. I am comfortable with that because I have been learning Java for the last five to six years.

Spring Boot has many valuable features. First, it requires less coding and less configuration. The configurations are already in-built. The security features in Spring Boot are in-built, so we don't need to use any external third-party applications for security.

In Spring Boot, the robust configuration capabilities help in adapting to diverse deployment scenarios because there is a minimum configuration required for developing any applications. The auto-configuration feature is available in Spring Boot. When we start any application, there is a property file where we mention the keys, securities, DB connections, and all other configurations. When we start any application, it loads the application properties first, which include the credentials and security files.

I am using Spring Boot starter projects.

I assess Spring Boot's auto-configuration feature as highly efficient in managing application setup. The application.properties file allows us to specify the server settings, such as the port we want to start the server on. For example, the default is 8080, but we can configure it to 8081. Additionally, we can store connection details such as the driver class, data source URL, username, and password in the application.properties file.

There is potential for improvement in Spring Boot. Most features are already available, but they could work on integrating AI applications. Maybe a module could be enhanced with AI features.

I don't have more features or functionalities in mind apart from the AI functionality, as I find that most of the essential features are already available in Spring Boot.

I have encountered performance and stability issues in the on-premises usage of Spring Boot. In the cloud, the performance is significantly better, with multiple CPUs available. When we installed it on local servers, there were performance issues that arose when integrating cloud services with on-premises applications, resulting in lower performance locally.

Regarding scalability, cloud services are highly scalable. In the on-premises deployment, there might be budget constraints and higher costs. With cloud scalability, we can accommodate application usage that scales from a thousand users to ten thousand users easily.

I have used different Java development platforms before Spring Boot. In the earlier days, specifically around 2012 and 2013, I worked with the Struts 2.0 framework and Hibernate.

I prefer Spring Boot currently, as it allows for efficient development of small microservices, which is functionality not available in Struts 2.0. One significant feature of Spring Boot is its built-in security, whereas in Struts 2.0 we need to integrate third-party solutions for security purposes.

I have worked with the on-premises deployment model of Spring Boot, so I know the process for deploying in the cloud.

My advice for organizations looking to adopt Spring Boot is that if they are going online and require data security, they should go for Spring Boot services.

I don't see any significant disadvantages to Spring Boot, but one argument could be that the costing is higher. If every application is developed in Spring Boot, the cost tends to be higher compared to other technologies.

On a scale of 1-10, I rate Spring Boot a 9 out of 10.

I have used Spring Boot for multiple cases, such as at Paytm, where our major stack was Spring Boot only. I used Spring Boot for building scalable backend microservices and REST APIs. At MakeMyTrip, I worked on a high throughput system related to payments, refunds, and booking flow, where Spring Boot helped in developing production-ready services quickly with features like dependency injection, embedded server, configuration management, and a strong ecosystem.

One project where I used Spring Boot was a refund processing system at MakeMyTrip. The system had to handle a high volume of refund requests coming from multiple payment channels and downstream banking systems. I used Spring Boot to build microservices responsible for refund orchestration and transaction status handling and callback processing. An interesting part was handling asynchronous workflow using Apache Kafka. Since refund processing often depends on external systems, instead of blocking requests, we used event-driven communication and background consumers to process updates reliably. I built refund processing microservices using Spring Boot and Kafka, focusing on scalability, asynchronous processing, and resilience.

Another case where Spring Boot played a key role was in a payment and passbook communication flow where multiple downstream services had to call to fetch transaction-related details such as sender information, receiver details, bank metadata, and payment status. I used Spring Boot to build APIs that orchestrated this call efficiently, and since latency was important, we used multi-threading and asynchronous processing to trigger multiple downstream callbacks in parallel and aggregate the response before returning the final result. Spring Boot helped significantly because of its support of dependency injection, REST client integration, configuration management, and easy integration with concurrent processing mechanisms.

The best features offered by Spring Boot include dependency injection, REST client integration, auto-configuration, and production-grade features such as health checks, metrics, centralized configuration, and monitoring through Spring Actuators.

These features, such as REST client integration and dependency injection, are used daily. With REST client integration, we create REST APIs, and dependency injection in Spring Boot allows components to be loosely coupled and easier to test and maintain. In large microservice systems, this made the codebase much cleaner and helped different teams work independently without tightly coupled implementations. Auto-configuration was especially useful because it moved a lot of manual setup. For example, when integrating databases or Kafka, Spring Boot automatically configured many common components based on dependency and configuration files, reducing boilerplate code and speeding up our service development significantly. Furthermore, we use health check endpoints and metrics to monitor service health and traffic behavior, combined with tools such as Grafana, to identify issues such as increasing latency, downstream failure, or even thread pool bottlenecks much faster.

In addition to the features I previously mentioned, Spring Boot also offers centralized configuration and profile-based environment management, which made handling different deployment environments and downstream failures easier. The ecosystem around testing was very useful, as support for integration testing, mocking, and embedded testing configuration helped improve code quality and made deployment safer.

One major benefit was faster service deployment because Spring Boot reduced boilerplate configuration and provides production-ready features out of the box, allowing teams to build and deploy microservices much more quickly.

Spring Boot is very mature and developer-friendly, though it abstracts a lot of complexity, which can make it difficult for a developer to fully understand what is happening in the background. In large-scale systems, this can occasionally complicate debugging and performance tuning. Additionally, for very light or serverless use cases, Spring Boot applications can feel heavier compared to some newer, lightweight frameworks. I also think configuration management can become complex in very large microservice ecosystems, especially when there are many environment-specific properties and integrations involved.

Although Spring Boot has very strong documentation, the extensive ecosystem can sometimes make it difficult for a developer to identify the best approach among multiple available options. For beginners, concepts around auto-configuration, annotation, bean lifecycle, and dependency management can feel overwhelming at first. Additionally, since Spring Boot abstracts many internal configurations, troubleshooting issues such as circular dependencies or bean conflicts can become complex in large applications. Dependency and version compatibility across the Spring ecosystem sometimes require careful management, especially during upgrades in enterprise projects.

The main area I see for improvement in Spring Boot is in reducing complexity in very large enterprise applications. Key improvements would include optimizing startup performance, easing debugging of framework internals, and simplifying configuration management in large systems.

I have been using Spring Boot for around three and a half years.

Stability was also one of the reasons we did not pursue other options, as Spring Boot is very stable.

Spring Boot scalability is good, especially for enterprise-scale backend systems. One of its biggest strengths is that it works naturally with horizontally scalable distributed systems, as services are typically stateless, making it easier to scale instances independently based on traffic or workload. In my experience working on payment and refund systems at MakeMyTrip, Spring Boot integrated very effectively with technologies such as Apache Kafka for asynchronous processing, which helped handle high throughput workloads more efficiently.

Spring Boot is highly used for backend systems and is an open-source framework, so there is not a traditional vendor support model that commercial enterprise products offer. Most support comes from its extremely strong community ecosystem, official documentation, GitHub discussions, and Stack Overflow. I have not needed formal support, as the documentation and community resources are usually detailed enough to solve most issues quickly, which is one of Spring Boot's biggest advantages.

Before Spring Boot, many enterprise systems traditionally relied on heavier Spring configurations or monolithic application approaches. Compared to those, Spring Boot simplified development significantly using auto-configuration, embedded server, and standardized project structure.

I have observed a noticeable improvement in development speed and maintainability. For example, due to auto-configuration, starter dependencies, and embedded server support, setting up new microservices became much faster compared to traditional Spring-based setups, which earlier could take days of manual configuration, often reduced to much shorter deployment cycles. Maintainability also improved because Spring Boot encouraged a standardized product structure and modular design pattern, making it easier for multiple teams to collaborate, onboard new developers, and troubleshoot services consistently.

Although I cannot share exact internal numbers, I have clearly seen a strong return on investment from Spring Boot in backend development. One major area was development speed and maintainability. We also noticed benefits from reduced infrastructure and licensing costs because Spring Boot is open-source and integrates with existing ecosystems. It improved development productivity, enabling teams to scale services efficiently without proportional operational overhead.

Although I was not directly involved in the pricing, setup cost, and licensing aspects, the framework is very cost-effective while still providing enterprise-grade capabilities.

Before choosing Spring Boot, we evaluated other options such as Spring MVC setups without Spring Boot and lighter frameworks such as Micronaut for Java-based development.

My advice to others considering the use of Spring Boot is to strongly recommend it for building scalable backend systems or microservices, especially using Java. My main advice would be to first understand the fundamentals of Spring, such as concepts of dependency injection, bean lifecycle, and configuration management, instead of relying solely on annotations and auto-configuration, as this understanding helps significantly when debugging and designing large systems.

Overall, Spring Boot is one of the most impactful frameworks for Java backend development. What stands out to me is how efficiently it balances developer productivity with enterprise-grade capabilities. It simplifies building scalable microservices while providing strong support for reliability, monitoring, security, and integration. Spring Boot is a mature, scalable, and highly productive framework that works extremely well for enterprise backend systems when combined with good architectural practices. I would rate this framework a 9 out of 10.

Spring Boot is used for standard web application processes such as REST API, API management, and API calls that we implement as part of the microservices implementation for banking and insurance processes. It is implemented differently, as we work for ADO, Microsoft ADO, connecting with the ADOs and then capturing the data that is required for the organization and implementing framework that I am using.

Spring Boot is very valuable because it can accommodate any number of implementations that can be done by microservices, and it has many advantages when used on top of Java.

We have a library in Spring Boot to initiate any project, which helps us implement the required libraries.

I use Spring Initializr, which we generally start with for any specific project to implement Spring Boot applications. These implementations can be done with Spring Boot, specifically for web applications, mobile applications, or any sort of application.

Typically, any annotations we want or anything we need to annotate and configure the components are definitely used. It is part of the framework that makes configuration easier to implement in any Spring Boot application.

I have not evaluated such scenarios because what we currently have allows us to use it effectively. We always face one challenge with Spring Boot applications when libraries are updated, libraries have changed, or class loaders or class-level implementation are modified based on Java or other libraries. At these times, we definitely face challenges, but this is something developers must handle by identifying the right library. Because it is open source, all external systems are actually external to Spring framework. The challenge could be addressed through auto-identification or auto-configuration based on versioning since version-to-version libraries are different. Based on versioning, that would be really helpful.

I have been working specifically with Spring Boot for five years, and with Spring MVC for more than 10 years.

There are alternatives for Spring Boot, such as .NET applications or Node.js implementations, though the market strongly favors Spring Boot microservices. There is also an evolution we are seeing from Python. However, Python and Java work differently, so we cannot compare both in different scenarios. For web-based, mobile-based applications, and services APIs, Spring Boot microservices with Java would be the best option. Node is also suitable.

Spring Boot Initializr is what we generally use for the setup of initial configurations.

We identify the libraries based on requirements and configure them accordingly. The challenges arise when there are version matching issues. If versions or dependencies are modified, problems begin, which is when developers face challenges.

I rate Spring Boot 9 out of 10.

Currently, I have not experienced anything specific or special with Spring Boot; it is a technology stack I work with for Java and J2EE activities.

We use standard Amazon Spring Boot and implement it for client projects wherever required, doing app development for them.

For monitoring, we do not use the core Spring Boot because we generally use Spring Boot MVC and additional configurations with the cloud. There are two approaches: implementing an Actuator in the application or using cloud-specific monitoring, tracing, logging, and exception mechanism tools. We implement basic exception mechanisms in applications, while monitoring and tracing processes are configured with the cloud.

Spring Boot's robust configuration capabilities are very effective in deployment processes embedded with Spring. There are multiple deployment methods, including standalone and embedded servers, depending on requirements. We primarily use cloud deployment, implementing CI/CD processes through Jenkins build processes. Applications are deployed as containers on AWS or Azure containers. Standalone Spring Boot applications can create Docker images for server execution.

Spring Boot is deployed mostly on cloud, though sometimes we use it on-premises. Currently, the applications we work with are predominantly cloud-based.

Spring Boot is used with the Apache Camel framework for creating web services and APIs, as well as for database interactions, primarily for backend APIs. Since December 2024, work has been conducted on the Apache Camel framework, which is an open-source option, while Red Hat Fuse is the licensed product version. Apache Camel and Red Hat Fuse are essentially the same thing, with minimal differences between them. There have been no significant updates from either in the last two years.

Spring Boot has been used in conjunction with Apache Camel within the last year.

Spring Boot's most valuable features include its ability to provide a microservice environment. Microservices can be created using Spring Boot, allowing simple APIs to be bundled together and deployed to servers as small chunks of APIs. The framework is tightly coupled, enabling the creation of multiple APIs. Spring Boot provides numerous features such as security and monitoring capabilities.

Spring Boot's starter projects allow for project creation within the spring.io initializer. Once a project is created, dependencies can be added according to requirements. For example, SQL dependencies are available for SQL and MS SQL databases, and Camel dependency is available for the Camel framework. REST APIs can be called using HTTP dependencies, which can be added to the POM to write code.

Spring Boot provides numerous annotations for managing application setup efficiently. Examples include @Component and @Value annotations. The SpringBoot @SpringBootEnableConfiguration annotation can be used in the main application for configuration purposes.

Spring Boot's robust configuration capabilities allow applications to be deployed using a JAR, which is a bundle. Lightweight JARs can be deployed to servers by creating a JAR in the target folder once the application is run. Applications can be deployed to any environment, whether cloud or on-premises.

The Actuator for monitoring has benefited application management. A common actuator endpoint called actuator/health provides the status of the application and information about applications by simply hitting the APIs. HTTP traces and requests can be obtained as needed.

Positive impacts have been observed since starting to use Spring Boot in the company because it is a framework that allows for easy creation of microservices. Multiple APIs can be created easily. Annotations in Spring Boot make it straightforward to use and write code. The framework is set with a controller, model, entity, and security, requiring only the writing of business logic, and deployment is very straightforward.

Spring Boot does not have the capability to process large amounts of data, such as thousands or even 10,000 to 50,000 records, faster. In Camel, strategies such as aggregation and batch processing allow for faster record processing. This is an area where Spring Boot needs to improve.

Spring Boot has been used for almost four to five years.

Spring Boot is stable and reliable.

Spring Boot is very good technology in terms of scalability where microservices can be created, which are powerful features in the current market. It is straightforward to use and write code.

Technical support for Spring Boot is easily accessible since it is open source, and an abundance of information is available.

The online documentation for Spring Boot is sufficient; it has already been developed and many users are using it. With AI tools such as ChatGPT, obtaining information is easier.

Before Spring Boot, Apache Camel was used, which is the Red Hat framework and also a free option. Red Hat is the licensed version, but an open-source option is available with Apache Camel as the framework. Microservices can be created using Apache Camel similarly to how they are created with Spring Boot by adding the Camel framework dependency and writing Java DSL. Both Java DSL and XML DSL can be written in Apache Camel as well as in Red Hat Fuse, and experience exists in both DSLs.

These products have been used simultaneously.

Spring Boot, Camel, and Red Hat Fuse have been worked on as part of an evaluation of options before settling with Spring Boot.

The setup for Spring Boot is straightforward. The project structure is created by going to spring.initializer.io, where the project structure is created. The project is imported into an IDE, such as IntelliJ, and code can be started from there.

Apache Camel framework is currently being worked on rather than Red Hat Fuse. Red Hat Fuse is essentially the Apache Camel framework that was worked on earlier.

Red Hat Fuse was used approximately two years ago.

Spring Boot Actuator has been used.

Outages or downtime are dependent on the requirement and how applications are developed and designed. When working with large amounts of data, infrastructure requirements must be addressed, such as providing memory or creating replicas. Those considerations must be addressed depending on the requirements.

The review rating for Spring Boot is 8.5 out of 10.

I am working on a Spring Boot project. I have been working with Spring Boot for four years. I basically use it mostly for creating microservices.

The best feature in Spring Boot is that it's pretty easy to create any project from scratch and we get a lot of boilerplate code from Spring Boot. I have utilized the starter projects in it. It has fastened up my development processes.

While using Spring Boot, it's pretty easy to create the controller and microservices and repository call. We don't have to specifically define how the database call needs to be made. We just create the JPA and it handles it internally. We don't have to bother about a lot of stuff. We are only focused with the business logic.

There are tons of improvements that we can do in Spring Boot. I would start with having a default configuration. Whenever we are fetching data from the database, if the value is null, if the column contains a null value, then it creates a null pointer exception in the whole service. This could be one of the improvements where we can keep it configurable. If the database is returning null then we would have some default data. These can be on the part of the entity.

On the security part, there is a lot of improvement that can be done and also on the documentation side. The way we configure the security is a bit complicated.

I have been working with Spring Boot for four years.

I have not had any downtimes, crashes, or stability issues with it.

I find Spring Boot scalable.

I haven't evaluated other available options because Spring Boot is so popular that we don't even bother thinking about other options.

It was pretty straightforward.

They can also consider Node.js because when it involves a lot of data streaming or data processing, Node.js is a winner.

For deployment purposes, it's pretty easy to deploy Spring Boot services. I have deployed Spring Boot applications in the cloud.

In the cloud, I have utilized App Runner service for deployment of Spring Boot services, BeanStalk as well and apart from that, ECS. We only have to create the Docker image and then we have to just tell the services that this is the Docker image, this is the port and this is where the health check needs to be done.

If it's a straightforward application that needs to be built, then we can go with Spring Boot. It's pretty easy and good for rapid development.

I rate Spring Boot a seven out of ten.

I use Spring Boot because it is not different from what we already have. It is similar to what we use, and we have part of it integrated. It usually works well with Spring Boot.

I can provide an example of how Spring Boot helps my organization. Spring Boot is not different from our current setup, and it is similar to what we use. We have part of it integrated, and it usually works well with Spring Boot.

In my opinion, the best feature in Spring Boot is its inbuilt Tomcat server.

I don't think there is anything that should be improved in Spring Boot as it is working well and good. I would just say having certain capabilities within Spring Boot so that the app teams can stop using alternative solutions.

I would appreciate seeing a dashboard added to Spring Boot.

I have been using Spring Boot for five years.

Regarding Spring Boot, it is not the most stable option. We are transitioning away from Spring Boot to Webex.

Spring Boot is demonstrating scalability.

It is straightforward for me to deploy Spring Boot, and it is secure.

I would advise someone who would like to use Spring Boot that if they are building a highly trafficked API, they should not use Spring Boot and should instead use Webex. The reason is that Spring Boot has very limited resources when processing messages, but Webex has a smart way to utilize resources using an event bus in a pub-sub design pattern. I would therefore advise Webex. Overall, I would rate Spring Boot six out of ten.

I am an integrator and a consultant when it comes to Spring Boot. The usual use cases for Spring Boot that I work with mostly involve an enterprise open-source platform which I can custom build any one of my solutions. I build OLTP systems, or I build ERPs. It is a custom framework which helps me build my custom solutions.

The features of Spring Boot that I have found the most valuable include multiple components which help bootstrap a lot of things. If you have worked on any core development, then there are a lot of concerns with respect to setting up authentication, setting up database connectivity, monitoring, and integrations with other systems via queues. Spring Boot comes up with a lot of connectors to all the ecosystems which help bootstrap the enterprise solution much quicker and faster.

I assess Spring Boot's auto-configuration feature in managing application setup efficiently as helpful to certain basic projects, but for advanced projects, I do custom configuration injections. For basic projects, I use autoconfig, but for anything advanced, I wire them by using the APIs.

Spring Boot's actuator for monitoring is quite useful with respect to the integrations it has to monitor the application and know the health. It is more or less unified and can be integrated with any orchestration systems like Docker. I do use actuator.

Areas of Spring Boot that could be improved or enhanced include its open-source ecosystem where a lot of improvements happen. It is not a paid product. However, what would be helpful is probably a console where I would be able to give in specific commands to bootstrap it much faster.

I have been using Spring Boot since it has existed, so it is the solution I have been utilizing since starting my career.

I find Spring Boot quite stable, because it is a mature library with a lot of fixes and a stable release process. It is quite reliable and stable.

From a user scalability perspective, Spring Boot is pretty scalable when handling multiple concurrent requests. Anything which is to do with enterprise scale, as far as Java is concerned, Spring Boot has all the best practices factored in. It is quite scalable to a factor of thousands of requests per second.

I have participated in the initial setup and deployment of Spring Boot. My experience with the setup and deployment is that it has come a long way. From the days when I started initially using Spring Boot when there were no starter projects to right now with the starter projects coming in, it has come a long way. There has been a drastic improvement in the way the setup as well as deployment is done. It is quite easier now.

Since Spring Boot is an open-source tool, I do not have to pay anything for Spring Boot.

I have utilized Spring Boot's starter projects. They act as a kind of accelerator to bootstrap or quickly get started with the development because the core plumbing code is already set up.

In DevOps deployment scenarios, Spring Boot's configuration capabilities help me adapt to diverse deployment scenarios by allowing me to inject the parameters using environment variables, especially in the case of Kubernetes. I use them in order to inject config properties into my runnable Spring Boot applications.

I have generally deployed Spring Boot applications in orchestration containers which are available on cloud platforms like AKS, Azure Kubernetes Services.

I would rate this product a 9 out of 10.

We started using Spring Boot because we wanted to implement the microservice- based architecture. We selected Spring Boot to develop our services using the Spring framework.

We deploy the solution on-premises and on the cloud. On the cloud, we deploy it through Azure and AWS. We've also deployed it on PCF, which is a cloud agnostic platform.

We're using version 2.x.

There are 130 members in my organization who use String Boot. These users include the development team, the testing team, the administration team, and the deployment team.

It's annotation-based for developing the framework, which minimizes a lot of coding. It also improves the time to market and makes it easily deployable and configurable. We can provide security easily and develop the CQRS pattern.

The API gateway and cloud configuration allows us to configure the properties outside of the service with respect to enrollment. We can also provide security to those with basic credentials who are authorized to access it. 

We also have a circuit breaker pattern, which provides resiliency. If service goes down, there is a fallback mechanism, which enables the application to be up and running, even if the service is down. There are multifold benefits.

Spring Boot is a bounded framework. The services we develop are purely synchronous services, so there's a blocking and waiting state. This is a big problem in microservices. To avoid this problem, we have to make the service a reactive session. It has to be reactive to a particular load, particular condition, or based on the number of requests hitting the particular service. All these factors make the service a reactor. There's another module in which Spring Boot provides spring reflex.

This module enables the reactiveness of the service, meaning that it eliminates the blocking and waiting state. For example, if you're sending a get operation or a post operation, there won't be any waiting for it to actually hit that particular network to get the data from another service. It continuously flows the request, and there is a zero waiting pack. Vert.x is another good framework where there are similar features or similar benefits with having a reactive session.

Spring Boot is a license resource, so it's a framework where we can customize our solution or a particular requirement to build a good solution using Spring Boot. But it's an opinionated framework, meaning that it's completely bounded. You have only one direction to find a solution, whereas Vert.x is an unopinionated framework.

Unopinionated is a kind of a toolkit where you can have more optimization and a more flexible solution, which is suitable to your requirements. In Spring Boot, the opportunities are limited. With Vert.x and other programming tools, we have multiple options to explore the solution in a different way and achieve a nonfunctional requirement of thousands transactions in a second. Spring Boot might not support this kind of non-functional requirement. Vert.X is a very good solution to solve critical NFRs for a particular application.

I have used this solution for five years.

The stability is good. I would rate the stability as eight out of ten. We can customize and configure the service of a particular requirement or enhance another particular requirement.

I would rate the scalability as seven out of ten. 

Spring Boot is scalable at an infrastructure level, meaning that we can increase the number of instances based on the load on the particular service or particular application. It's infrastructure-level scalability. There is also inbuilt scalability of the service. For example, Web Flex and Vert.x have inbuilt scalability, meaning there is scaling of service inside the service, not outside the service, such as infrastructure. The design level scalability should be implemented first.

There's no vendor support for Spring Boot. It's free source.

I would rate the setup as seven out of ten. 

Setup is straightforward. The initial solution is very straightforward, but there are critical use cases in the microservice-based application, where the data size, number of transactions, and the number of users is huge.

We created a CI/CD pipeline into continuous integration and continuum deployment using Jenkins, which deploys on-premises and on the cloud, such as on Azure Devops, AWS, PCF, or even a Kubernetes cluster.

Deployment took a few minutes. I deployed the solution. I'm a chief architect, and we have a DevOps team of five members. They support multiple teams using the solution.

The return on investment is good because the time to build and deploy is reduced, and it's easy to develop. It's free source, easy to learn, flexible, and scalable.

Spring Boot is open source. It's a free tool and free framework.

I'm not very fond of Spring Boot. I have other frameworks, including Vert.x and RxJava. RxJava is another important enhancement of Java. These are the frameworks that enable us to create services. 

l would select these reactive frameworks rather than non-reactive frameworks, such as Spring Boot. My recommendation is that the application should work, even 10 years down the line. Today, I'm dealing with 10 gigs of data. Tomorrow, I may deal with 100 gigs of data. We have to build applications for the future requirement, not for today's requirements.

I would rate the solution as eight out of ten. 

I recommend using all of the functionalities of the framework to solve the non-functional aspects of the problem, not just the functional aspects.

I would recommend this solution depending on the requirement, including the non-functional requirements, like the performance, scalability, reporting, and response time. These are very critical to achieve SLAs, so my recommendation depends on these factors.

My team uses Spring Boot to build APIs. We're running Spring Boot for 90% to 95% of our ecosystem. When you talk about the Java system, Spring Boot is the only framework we're using right now.

Spring Boot's configuration is easy, and it has an out-of-the-box deployment.

Spring Boot's cost could be cheaper.

I have been using Spring Boot for five years.

Spring Boot is not too stable on the cloud, and it normally consumes a lot of memory and CPU.

Spring Boot is a highly scalable solution. Around 200 to 250 users are using Spring Boot in our organization.

We previously used Apache Camel.

Spring Boot's initial setup is straightforward.

We have an in-house deployment, where they restrict your deployments into the cloud so that we can do on-prem setups. Then, you can deploy applications into the back setup.

Spring Boot is a cloud-based solution. I highly recommend Spring Boot for users who do not process highly sensitive traffic.

Overall, I rate Spring Boot an eight out of ten.

We use the solution to manage our microservices. It helped us develop a web application portal for a financial company.

We are a financial technology company. We chose Spring Boot because it provides additional security layers, essential for the sector. Moreover, it offers powerful tools and technologies that enable us to focus on specific microservices. It is crucial because the banking industry and financial technology typically rely on a monolithic architecture, where the failure of one service affects the entire system. However, with Spring Boot, a cache in one microservice only impacts that particular service while the others remain unaffected. It is significant considering the large number of users who utilize banking applications.

The solution has the best security features. Thus, financial services providers use Spring Boot's framework incorporated with Java to add a security layer. Moreover, it works as a standalone framework to create applications that can run without relying on external web servers or being embedded within a web server like Apache Tomcat.

The solution needs more applicable control for large-scale application development. It is a time-consuming process to convert a framework to an application. Also, it requires integration with other platforms, making it even more complicated. We cannot use it directly in existing projects utilizing the framework. These particular areas need improvement.

We have been using the solution for more than three years.

It is a highly stable and valuable product when integrated with Java technologies.

We have more than 100 backend developers utilizing the solution. It is scalable, but it depends on the infrastructure that you are using. Also, it requires specific knowledge of managing loads and deployment of microservice applications.

We have yet to contact the solution's technical support team. There are times when we encounter problems. Fortunately, we have a subject matter expert in Spring Boot whom we consult. However, we will seek assistance if we experience any high-level technical difficulties.

The solution's initial setup process is simple. It is easy to learn, even for a beginner using it.

The solution is an open source tool.

The solution is a great technology to learn. It provides default configurations for codes, including dependency injection and inversion of control. It simplifies development, especially for Java developers, as it reduces the need for writing boilerplate code and configuring various aspects. Additionally, it enhances productivity and facilitates unit testing, integration, and test processes. Furthermore, it seamlessly integrates with its ecosystem, including Spring JDBC, Spring Data, Spring Security, etc.

Overall, I rate it a ten out of ten. It has many capabilities including ease of learning and use, and it reduces development time as well.