My company is considering consolidating all their tier-1 (i.e. top end production) applications and sites into one all-encompassing code base.The theory is that their permissions, design and overall functionality can be homogenised and centrally managed.I have no end of concerns about this approach since the data structures underpinning each application are very different, the business rules are complex and unique to each application and the overall code bases for the existing applications are extremely disparate and very neglected.EDIT:The current environment consists of three ASP.Net 1.1 sites that have barely seen any real love since first being written (due chiefly to an absence of experienced developers in the company) and one MVC2 application that was also an ASP.Net 1.1 site before being upgraded last year. We write exclusively in C#.The company is a fairly small one, with about 50 staff; three of whom are actual developers. Management (even IT management) do not have any IT background or experience other than project management of IT projects (and therefore some passing knowledge of terminology and business impacts).The applications are chiefly online services to support the products sold by the company. The company doesn't sell any software directly.So to phrase this whole situation in a reasonably specific and answerable question: What are some compelling reasons for and against trying to pull all your systems together into one over-arching solution given the current conditions (i.e. old code base, complex business systems and rules)?
What considerations should be given for and against super sites?
asp.net;enterprise architecture
Bad ideaThis reaction is based on the following assumptions:There are a lot of fairly disparate applications being homogenisedThere are many teams working on the different applicationsThere is no well-respected and authoritative software architect actively managing the applicationsWhat will happen if you go aheadMost likely there will be an inital consolidated effort to bring everything together under a single design approach. This will show up the huge effort required to make everything work the same and may get canned as being unworkable. If it presses on then some kind of centralised repository containing configuration data (e.g. security access, logging levels etc) will be required at which point someone will point out the obvious and say Hey, why don't we just retrofit this  externalised configuration approach to  the old applications, it'll be much quicker?and a moment later someone else will pipe up withAnd, since we're refactoring anyway,  why don't we just apply a design  standard for each of the application domains - web  processing looks like this, business rule  processing like this and database  access like, er this.until finallyOh, and there's a lot of common code here why not put together some  easily shared libraries. We'll probably need some kind of integration build run at regular intervals, say, every night.At which point everyone breathes a sigh of relief that an enormous monolith was not constructed.