For the longest time whenever the question of software architectures in web applications came up, the N-Tier architecture was the front runner. And why not? It is flexible ,scalable,very easy to model and more importantly - easy to communicate. In fact it is so common that there are code generation tools, and frameworks galore for it. I like N-Tier architectures - for the reasons I mentioned before - however, I have seen many occasions where this particular approach is used as a panacea for all ills. Every application - regardless of its size or the business problem is given the N-Tier treatment :-) In most cases this is overkill - especially in departmental intranets that service a finite number of people. Sure, the solution would be scalable and flexible but that comes at a cost - performance - N-Tier architectures - in my experience, are actually slower when compared to single tier architectures - more scalable but slower… This means that if your web application has an audience that is fairly stable and specific business requirements you would be better off designing a simpler application that meets the need. By lowering the number of objects that need to be instantiated and simplifying the logic needed, a significant improvement in performance, as well as a marked reduction in the complexity of the code could be achieved. The biggest argument against this approach is of course that of ever changing requirements and scope creep and the need to obviate that by introducing flexibility in the code. The argument is a valid one and compelling one. However, this risk can be mitigated by insisting on making clear the goal(s) of the application. Once that is clear, it is easier to distinguish between requirements that support the goal(s) and ones that change them completely :-) In my experience, there have been very few occasions where major changes in the goal(s) did not require a major re-design of the application - regardless of how modular and layered you make the application. In fact, in these cases it is far easier to refactor or even throw away and start again, if the application was not very complex to begin with. All this being said - I must point out that N-Tier applications have their place - all I am saying is that using them on every software problem is like using a bulldozer to drive in a nail - you could do it far more easily and a lot cheaper and easier with a hammer …