Utilizing eclipse to build your project is fairly rare, I would say. The by far most common way of building projects is using Ant. Some people let ant and eclipse coexist and complement each other, letting eclipse compile on-the-fly, then have the ant script checking the compile, running tests and packaging the product. If you ask me, I find it very verbose and fairly repetitive and hard to make a complete ant script doing compile, test, weaving, instrumentation, coverage reports etc for every project. Therefore I advocate maven, which really uses 'configuration by exception' and naming convention to manage really complex builds with minimal verbosity. Maven takes a long time to learn and is hard to 'wrestle' to do what you want in the beginning, wherefore I think many people dismiss it as overly complicated. When it comes to the code itself, Spring is very popular as a generic integration framework, providing adapter classes and tons of utilities to tie persistence, transactions, caches etc together to a more manageable product. It runs on java 1.3 onwards and is probably the only integration framework you will need for java. Enterprise beans are handy if you need to build non-stop applications. You get automatic persistence and reloading of state (immunity to application crash) with stateful beans. All EJB:s provide you with per-methodcall transaction setting. Ejb 2 was a horrible mess with a huge xml file and 2 interfaces needed for every class that you wanted to have. This was fixed with EJB 3.0, which is really nice to work with. Java EE also gives you persistent, transactional messaging, JMS. This is really a lifesaver if you are considering a HA app. Since Java EE is a standard, you can choose from many different servers providing these services, all with different gotchas. Generally, I find that there are two different groups within the Java community. One strongly advocates Spring, and declares Java EE 'a bloat'. The other group have embraced Java EE and try to take it further (see JBoss SEAM for example). I beleive that these two groups are closing in on each other lately, with the Spring people realizing what is lacking in Spring, and the Java EE people realizing that the framework can be much less intrusive and lightweight. Considering the build configurations, I think that you will see a big span, but I definately beleive that the possiblity of setting up a good build environment in Java is much greater, considering all the great available tools such as Emma, Maven, Ant (with Ivy), all the test frameworks etc.My impression is that there are two type of build stacks that you will: one fairly 'old school' with ant + jsp + libs, as you describe. However, there is also the other kind of people, who really have a full-blown stack with unit+regression+integration testing, ci with coverage, maven, spring+wicket or seam+JSF. But these are usually just the most motivated ones with time on their hands :)