If you come from Java/Spring the learning curve is quite flat. Grails is based on the concept of "convention over configuration" so if you follow the conventions you get rid of a lot of messy XML files.

Apart from this, you have all the power of the Groovy programming language, a much more modern language than Java, that allow the developer to build the business logic in a much more intuitive way.

As a summary, when you start to develop with Grails and you see that you have your environment and a running application in 15 minutes you won't leave this framework. Review collected by and hosted on G2.com.

One of the strengths of Grails is as well one of it's weaknesses. Grails can be extended via plugins, that are very useful to add integration with new functionalities, for example Spring-security, LDAP, etc. but sometimes there are so many plugins for one task that you have to choose carefully because some of them only work for specific versions, others are unmaintained, and this can be a problem. Review collected by and hosted on G2.com.

Working in groovy is great, so much less code! Grails has come a long way since I was a committer on it several years ago. The MVC structure is very easy to understand and the wide range of plugins make its quick to get projects going. Review collected by and hosted on G2.com.

Keeping up to date with the best practice/best plugins can be challenging as the framework has changed a lot in the last few major versions. I also find it hard to stay disciplined in keeping my GSP DRY and not repeating a lot of common code. Review collected by and hosted on G2.com.

The best part of Grails is GORM. GORM uses easy to learn and readable DSL to for interaction with Data Bases. Writing queries in GORM DSL and implementing relations from ER diagram is as simple as 1 2 3. Certainly GORM is not the only thing I like most. There are many more such as URL mappings, convention over configuration, extensive plugins, grails services and out of the box support for implementing RESTFul web-services. Although we did not use view layer (jsp/gsp) of grails for our web application, we use it extensively for internal applications used to manage our business process. Grails is so easy to use that we ended up creating few internal applications to manage our business process in Grails.

Apart from Framework, people behind its development are cooperative and its overall community is quite friendly. At many occasions, my reported issues were fixed within a day or two. Grails release cycle is quite fast, so you don't have to wait for the fixed issues to arrive in next stable release. Review collected by and hosted on G2.com.

Even though grails is feature rich full stack framework there are always room for development. One such example is its support for REST. Grails provide API versioning, response nesting and a lot of cool stuff but does not provide pagination or API meta-data out of the box. Grails response requires alot of customization for a production ready application Review collected by and hosted on G2.com.

It includes all the proven technologies like Spring, Hibernate, Sitemesh etc. It's built Groovy doing things differently is so easy. It gives so many things out of the box for which we tend to create our own solution. The project structure makes it's easy to understand where to put things. Best thing is it's GORM, Geb and Spock testing. Data binding, validations, inbuilt tags and creating own tags makes the life much easier that we tend to do in conventional way. The recent upgrade built on Springboot which makes it much light weight as well. The dynamic scaffoldin feature makes it much easier to do POC and MVP to showcase to clients. Plugin base architecture helps to create smaller services and reusability of code. It has a great community which serves to plugins e.g; integrating spring security is like 2 hours task which makes your development efforts really less. It has a in built capability of serving JSON response so creating rest application is like just adding annotation. Review collected by and hosted on G2.com.

It's a great framework, but it also needs a huge memory to run, this may be fixed with the Grails 3 which comes with Springboot. Second thing is GORM, since GORM provide so much query out of the box but sometimes it fails to meet the expected output may because of GORM bugs or due to hibernate bugs. Review collected by and hosted on G2.com.

The concept of reusability because of lots of vast number of plugins which would help to get lots things done with in just few minutes, like sms, email, various databases etc. Another, cool things I like about it is the vast community support and some very open and helpful people, which always help me very quickly whenever I am stuck. Review collected by and hosted on G2.com.

Honestly, I don't have any specific dislikes. And with the release of latest 3.x version it's adding more and tools to help build a very scalable applications. But, earlier I thought that it's only for web applications and which is not the case anymore. Review collected by and hosted on G2.com.

I like from Grails the order that the framework provides to your code. It is not just an MVC, but also includes ORM, GSP view technology and a build system. But what I like the best is the possibility to reuse your java-code on your web projects, even if you decide to code using Groovy, you still can use Java libraries on your project. Review collected by and hosted on G2.com.

For some reason I have had really bad times with some plugins conflicts and miss configurations that can take me hours to solve. It can be a total waste of time, over all when you have a tide deadline. Review collected by and hosted on G2.com.

The speed at which you can develop is unparalleled in my experience as a full-stack web developer. Convention over configuration is heavily used within Grails and once you start to understand these 'rules' allow rapid development.

I like the system they have in place to allow great separation of concerns (Views, Controllers, Services, client-side assets, config files, etc.).

The groovy language is a joy to work with compared to traditional Java - some of the built-in methods feel very LINQ-like if you are familiar with C#. These really goes hand-in-hand with Grails GORM database wrapper that allows for terse querying/persistence.

A huge plus is that changes to Class files can often be reloaded at runtime which makes development much faster than having to re-compile afterwards (this isn't perfect though).

Spring is a huge part of Grails and has been very nicely integrated. Review collected by and hosted on G2.com.

The documentation on many features within Grails is either sparse or nonexistent - many times I will receive an obscure error and dig heavily into old forums or framework source code to understand what is going on.

The dynamic nature of Groovy certainly has its pluses but can lead to bad practices by coworkers that make reading code much harder than it needs to.

The plugin ecosystem can be a nightmare when it comes to documentation and updates; but there are some gems out there as well (Spring Security, Asset-Pipeline).

Grails support does seem to be waning with Spring Source dropping the project.

The only IDE that really seems to work with Grails 3+ is IntelliJ ($$) but we are still using GGTS (Eclipse) with Grails 2.4 Review collected by and hosted on G2.com.

Convention over configuration (save time not writing configuration files and keeping everything sorted).

Robust technologies under the hood (Spring, Hibernate...). Groovy has advantages over Java (but you can also use plain Java while you master Groovy).

Very good for design patterns. Plugin system (Spring Security, Twitter bootstrap...).

Scaffold system (with templates you can, and should, edit)

You can work from the command line (generate domains classes, controllers, views...)

Modular framework: i like GORM, but if you don`t, you are able to remove it (you can even remove Grails and get a standard Spring application).

GVM tool (SDKMan right now) to manage framework versions. Review collected by and hosted on G2.com.

During development process the application server starts slowly, and needs a lot of memory. Review collected by and hosted on G2.com.

GORM(Groovy object relational mapping) is the feature I love best about grails. It hides away the complexity of hibernate without losing out on any of the power. Combined with the power of scaffolding putting out a proof of concept is a matter of hours not months. Review collected by and hosted on G2.com.

In the earlier versions of grails, maven support was not stellar. This has since been rectified. Review collected by and hosted on G2.com.

It is very easy to start a Grails application and start a web project. If you are unfamiliar with groovy, it has a fairly low learning curve if you have some experience with Java. Grails uses a programming by configuration system, where things must be named a certain way to get the magical grails metaclass interfaces. To do more advanced configuration, the maintainer should be familiar with Spring, as Grails uses Spring beans under its hood. Review collected by and hosted on G2.com.

There are many, many problems. If you use any of the advanced grails options, they are very brittle if not used exactly like designed, will not work at all.

Since Grails is using a dynamic language, the framework developer must maintain adequate unit test coverage to make sure that functions are being called correctly. If functions are not called correctly, then dynamic method Exceptions will be thrown all the way up the request stack.

The plugin ecosystem is completely un-maintained and plugins are usually out of date and most likely do not work with the version you are using.

There were many problems upgrading from grails 1.x to 2.x with completely broken changes. The 2.x to 3.x upgrade also broke many controller systems (we have not figured out our 2.x to 3.x upgrade, due to many issues).

The Grails project has reached its end of life, and is no longer being supported by its parent company Spring Source.

The GORM ORM for Domain class objects has many anti-patterns; the primary supported of Grails recommends that you do not use the join tables as documented, but instead use explicit join table objects as first class domain classes.

Service method implicit transactions will lead to many subtle bugs, even understanding what is going on it will still cause problems.

Review collected by and hosted on G2.com.