One of the worst mistakes that people make is trying to get approval for using
#dddesign. If you are doing it right, you shouldn't have to ask permission or get backing for
#dddesign. Really.
Most enterprise software could make major strides forward just by replacing the primitive obsession (many extraneous attributes or properties) in entities. That is, compose value objects with attributes that belong together:
String streetAddress1;
String streetAddress2;
String city;
String stateOrProvince;
String postalCode;
Blah blah;
Refactor these into a whole value:
public final class PostalAddress { ... }
Now you can test PostalAddress and you can test what uses PostalAddress. And when something changes in PostalAddress, you replace the whole PostalAddress--even when changing just one attribute.
Seriously, who would possibly complain about that? Okay, someone will definitely complain, but it doesn't mean they are smart, reasonable, or correct. This baby step--one entity at a time--will greatly raise the quality of your code and increase team knowledge.
Is this "full-blown DDD"? No, but it is iterative improvements. Once your quality and knowledge increases, take the next small step.
Again, if you are doing it right, you don't even refer to what you are doing as
#DDD. Just ask people who know what attributes belong to the same concept, and test/refactor/test. Many such decisions can be determined by using your own gray matter. You can even study the existing source code to understand what changes together. If 2+ attributes change together, they are probably related and belong in the same value type. (Except for the 35+ attributes that are all set together in a saveSomeHugeEntity() application service method).
Another but different place to start is in modularizing code per business concept cohesion.
The primary point is, the less people that you tell the better. Just do it and tell them later when you can prove that it worked and that your team benefitted.