Appearance
13.9 — The Enterprise Estate
You join a large company that has been running computers for forty years. Here is what you find on your first day.
- A Windows domain: every office computer and every login is managed from central Microsoft servers.
- File shares: folders on a central server that appear on each laptop as a drive letter, such as
F:. - An application server running Java software written in 2011.
- An integration platform: one central system that passes messages between forty other systems.
- A nightly batch window: the hours each night when large scheduled jobs run, because the systems are too busy during the day.
- A mainframe: a very large, very reliable computer of a design that dates from the 1960s. Nobody is allowed to change it.
- A change advisory board: a committee that must approve every change to a production system. It meets on Wednesdays.
Everything a company owns and runs, taken together, is called its estate. Your first reaction to this one may be that it is broken. It is not broken. It earns the company's money. People built it to solve real problems with the tools they had at the time. You become useful here once you understand why it looks the way it does. You cannot replace something you do not understand. And most of it will still be running in ten years.
1. The stack, layer by layer
The pieces sit on top of one another like layers, and people call the pile a stack. Here is the classic on-premises stack, from the top. The second column names typical products, and the sections below explain the unfamiliar ones.
| Layer | What it is | Who owns it |
|---|---|---|
| Application | Your code | Development |
| Data | Databases, files | DBAs, data team |
| Runtime | JVM, .NET, Node | Development / middleware |
| Middleware | App servers, message brokers, integration | Middleware team |
| OS | Windows Server, RHEL | Systems administration |
| Virtualisation | VMware, Hyper-V | Infrastructure |
| Servers | Physical machines | Data centre |
| Storage | SAN, NAS | Storage team |
| Network | Switches, routers, firewalls | Network team |
Two things to take from this table.
The cloud service models of Chapter 13.1 are this same stack with a line drawn across it. Below the line the provider does the work, and above it you do. With IaaS, you look after everything from the operating system (OS) upwards. With PaaS, you look after everything from the runtime upwards. With SaaS, you look after none of it. The shared responsibility table in Chapter 13.1 is this table seen from the cloud side.
Each layer has an owner, and the owners are different teams. Suppose the application is slow, and the cause could be the database, the storage or the network. To find it, several teams have to meet. You will hear "the network team says it is not the network". That is not people being difficult. It is the real cost of having many owners. In a cloud team you can change most of the stack yourself. Here you cannot, and that is the largest practical difference.
2. Storage and virtualisation
A SAN, or storage area network, is a large cabinet of disks that many servers share. The cabinet is called a storage array. It is connected to the servers by a network of its own, used for nothing else. Each server is given a slice of the array, and to that server the slice looks exactly like a disk plugged into it. Such a slice is called a LUN. Two kinds of cabling are used. Fibre Channel is the traditional one. iSCSI does the same job over ordinary Ethernet cables, which is cheaper.
A NAS, or network-attached storage, shares folders and files. A SAN hands a server a raw disk. A NAS hands many computers the same set of files. Windows machines reach it with a protocol called SMB, and Linux machines with one called NFS. This is the difference between block storage and file storage from Chapter 13.1, in the form it had twenty years before the cloud.
RAID is a way of combining several disks so that one can fail without losing data. People still use its vocabulary, so learn four levels.
- RAID 1 keeps the same data on two disks. This is called mirroring.
- RAID 5 spreads data across several disks and adds one disk's worth of parity. Parity is extra data from which the contents of any one lost disk can be worked out. It survives one disk failure.
- RAID 6 has two disks' worth of parity and survives two failures.
- RAID 10 mirrors pairs of disks and then spreads data across the pairs. Databases usually get RAID 10. It survives failures, and it avoids the extra work that calculating parity adds to every write.
Virtualisation is where enterprises first met the main idea behind the cloud (Chapter 2.9). Virtualisation means running several virtual machines on one physical server. The physical servers are called hosts. VMware and Microsoft's Hyper-V are the two common products. A group of hosts is managed as one pool, and the pool gives you five things:
- Live migration — move a running virtual machine between hosts with no downtime, which is how hardware is maintained without an outage.
- Automatic placement — balance load across hosts.
- High availability — restart virtual machines elsewhere when a host dies.
- Snapshots — a point-in-time state to roll back to. And the standard warning: a snapshot left in place grows without limit and degrades performance, so they are for a change window, not for backup.
- Templates — the golden image idea of Chapter 13.3.
The vendor picture changed sharply after 2023. Broadcom completed its purchase of VMware in November 2023. It then stopped selling perpetual licences, which a company bought once and owned, and moved to subscriptions only. It also folded dozens of separate products into a few large bundles, such as VMware Cloud Foundation. Many customers found their bill rose a great deal, because they now paid every year for a bundle that included things they did not use. This is the most common reason enterprises gave in 2024 to 2026 for moving virtual machines off VMware, to Hyper-V, Nutanix, open-source options such as Proxmox, Kubernetes-based virtualisation, or the cloud. If you join an enterprise now, there is a good chance a migration like this is in progress.
Understanding this makes cloud concepts land faster, not slower. An availability zone is a failure domain like a cluster; an instance type is a virtual machine specification; a managed disk is a LUN with an API.
3. Middleware and application servers
Middleware is software that sits between your application and the operating system and does common jobs for the application.
An application server is the main kind. It is a program that runs your application inside itself and supplies the things every business application needs. It keeps a pool of database connections ready. It manages transactions. It handles logins. It can run the application on several machines as one group. For Java, the well-known ones are WebSphere, WebLogic, JBoss (now called WildFly) and Tomcat. On Windows it is IIS.
Application servers exist because of how software was written around 2005. Nobody wanted every application to contain its own code for connection pools and transactions, so that code lived in one shared server. Modern frameworks include those parts inside the application itself. The application is then one self-contained program that needs no server around it. A container packages exactly that kind of program (Part 14).
What you will actually deal with:
- JVM memory and garbage collection settings (Chapter 3.4), tuned by hand for each server.
- Deploying a
.waror.earfile, which is a packaged Java application, into a server that is already running. - Several applications sharing one server. If one of them uses all the memory or threads, the others slow down or stop with it.
- Configuration stored in the server, not in the application package. Database addresses, passwords and pool sizes are set in the server's admin console.
That last point is why these estates are hard to make reproducible. Chapter 13.7's rule is to build one package and promote it unchanged, with configuration supplied from outside. Here the package is the same, but each server holds its own hand-set configuration. So two servers running the same package can behave differently, and nobody can rebuild a server exactly from what is written down.
4. Identity and file shares
Active Directory is the centre of a Windows estate (Chapter 8.4.8). It is Microsoft's directory of every user, group and computer in the company. It does three jobs. It checks who you are when you log in, using a protocol called Kerberos. It decides what you may access, based on the groups you belong to. And through a feature called Group Policy, it pushes settings to every computer and every user.
A great deal of business data still moves through file shares. A share has an address such as \\fileserver\finance\budgets. A small script that runs when you log in attaches it to a drive letter. A feature called DFS, the Distributed File System, gives one name to folders that live on several servers. So \\corp\finance leads to whichever server holds that folder today, and DFS copies the files between company sites.
This matters to you as an engineer because many systems still talk to each other this way. One system writes a file into a share, and a scheduled job in another system picks it up. It is not fashionable. It works, and it has been running for fifteen years. Replacing it with an API is a whole project, and not a quick tidy-up. Three things commonly go wrong with it:
- Permissions inherited from a group nobody can name. Access works for some people and not others, and nobody knows why.
- A file locked by a user who went home with it open in Excel. The overnight job cannot read it.
- A job that reads a file while it is still being written. It picks up half a file and processes half the orders.
The third one has a standard fix: write the file under a temporary name, and rename it when it is complete. The reading job ignores temporary names. A rename within one filesystem is atomic, which means it happens all at once. So the reader sees either no file, or the whole file, and never half of one.
5. Integration middleware
Integration means making separate systems exchange data. Suppose every system is connected directly to every other system that it needs. With N systems there can be up to N(N−1)/2 connections. Forty systems give 40 × 39 / 2 = 780 possible connections. Each one has its own data format, its own schedule and its own way of handling errors. Changing any one system might break dozens of connections, so in the end nobody dares change anything.
An enterprise service bus, or ESB, puts one system in the middle. Every system connects once, to the bus. The bus does three jobs. It routes: it sends each message to the systems that need it. It transforms: it converts the message from the sender's format to the receiver's. And it orchestrates: it runs a process of several steps across several systems.
webMethods is a common example, and its parts are representative of the category. It was built by Software AG, and since July 2024 it has belonged to IBM, which bought it together with the data tool StreamSets. You will see both company names on it.
- Integration Server — runs the integrations, hosts adapters and services.
- Universal Messaging / Broker — the asynchronous messaging layer.
- Trading Networks — business-to-business document exchange, especially EDI.
- Adapters — pre-built connectors to SAP, JDBC, mainframe systems, SOAP and file systems.
MuleSoft, TIBCO, IBM Integration Bus and Microsoft BizTalk are products of the same kind. The modern form is iPaaS, integration platform as a service, which is an ESB that a cloud vendor runs for you.
A bus solves a real problem and creates two new ones. First, it becomes a bottleneck. Every change to any connection has to wait for the one team that runs the bus. Second, it becomes a single point of failure. When the bus stops, all forty systems stop talking. These two problems led to the microservices idea that each team should manage its own connections (Chapter 10.8.3). Those teams then found that they still needed routing, transformation and reliable delivery. So the same jobs came back under new names, as API gateways and event brokers.
The distinction worth being able to state:
| Does | |
|---|---|
| ESB | Routes, transforms, orchestrates between many systems |
| API gateway | Fronts APIs: auth, rate limits, routing (Chapter 13.2) |
| Event broker | Publish-subscribe delivery, no transformation (Chapter 10.8.1) |
| iPaaS | ESB as a managed cloud service |
Files are the other half of integration. A simple setup is a script that runs on a timer and copies files to another company over SFTP, a secure file-transfer protocol. That setup keeps no record of what was sent, and it does not retry properly after a failure. Managed file transfer products do the same job and add scheduling, encryption, retries and a full record of every transfer.
EDI, electronic data interchange, is a decades-old standard format for business documents such as purchase orders and invoices. North America uses a version called X12, and most other regions use EDIFACT. A very large share of the world's trade is still carried out with EDI. You will also meet plain text files everywhere, laid out in an arrangement that the two sides agreed long ago.
The nightly batch window exists for a good reason. During the day, the main systems are busy recording sales and payments. A large reporting query at the same time would slow them down (Chapter 7.8.1). So the data is copied out at night, when the systems are quiet. The window is a decision about capacity, and it is not laziness. When someone asks "why can't this report be live?", this is the real answer.
6. Mainframes, and why they are still there
A significant share of large banks, insurers, airlines and governments still run their most important work on IBM mainframes. You will hear five names around them. COBOL is the programming language, dating from 1959. CICS is the software that runs transactions. DB2 is the database. JCL is the language for describing batch jobs. And "3270" is the kind of text-only screen that people use to operate it all.
Mainframes are still here for four reasons.
- They work, with reliability and transaction throughput that is genuinely excellent for their workload.
- The business logic is decades of accumulated rules, much of it undocumented and all of it still in use.
- Rewrites have failed repeatedly and expensively, and organisations have learned from watching each other.
- The migration risk is asymmetric: the upside is lower costs, the downside is not being able to process payments.
Integration patterns, in increasing order of quality:
- Screen scraping — drive the 3270 interface programmatically. Fragile, and it is what you do when nothing else is available.
- File exchange — batch extracts, the most common pattern.
- IBM MQ — reliable messaging, and mainframes speak it natively. MQ is very often the actual integration point.
- APIs over CICS — modern IBM stacks expose transactions as REST or SOAP, which is the right answer where it is available.
The modernisation pattern that works is the strangler fig (section 8), not a rewrite.
7. The Microsoft data stack
An enormous amount of the world's business reporting runs on this, and it is worth knowing what each piece is.
SQL Server — the relational engine (Chapter 7.1).
SSIS (Integration Services) is the ETL tool. ETL stands for extract, transform, load: copy data out of one system, reshape it, and put it into another. A unit of SSIS work is called a package. You build a package in two separate visual editors, and you need to know what each one is for:
- Control flow — the sequence of tasks: run this, then that, branching on success or failure, with loops and precedence constraints.
- Data flow — inside a data-flow task, a pipeline of source → transformations → destination, moving rows in buffers.
Packages are deployed to an Integration Services catalogue with environments, parameters and execution logging, and scheduled by SQL Server Agent.
Why SSIS persists: thousands of working packages, staff who know it, and a strong story for on-premises sources — flat files, Excel, mainframe extracts, and every ODBC source. It is also visual, which makes it maintainable by people who are not developers, and hard to review in a pull request, because the package is XML that does not diff meaningfully. That last point is the real modernisation argument.
SSRS — paginated operational reports, the kind that must print correctly.
SSAS — analytical models: the older multidimensional cubes with MDX, and the newer tabular model with DAX, which is the same engine underneath Power BI.
Power BI — the current reporting layer, with a semantic model, DAX measures, and refresh schedules. The failure everyone hits is a model importing a hundred million rows and hitting refresh limits — the answer is a proper star schema (Chapter 7.8.1) and aggregation, not a bigger capacity.
The modern path: Azure Data Factory for orchestration, Synapse or Fabric for the warehouse, and dbt-style transformation in the warehouse (Chapter 7.8.2). Migrating SSIS is usually a rewrite rather than a lift, which is why estates run both for years.
8. Change management, and working within it
Large companies organise their IT work along the lines of ITIL, a widely used set of practices for running IT services. ITIL gives you four words. An incident is something broken right now. A problem is the underlying cause of repeated incidents. A change is any alteration to a production system. And the configuration database is the record of every system and how the systems connect.
A change advisory board reviews and approves each change. A change is given a change window, which is an agreed time when it may be made, often at a weekend. It must also come with a written back-out plan that says how to undo it. A team that is used to releasing twenty times a day finds this absurd. The reasoning behind it is sound. When a failed change stops a bank's payments, the cost runs into millions, and the regulators take an interest.
Do not fight the process. Make your changes so safe that the process lets them through. Three things help:
- Standard changes — pre-approved, low-risk, repeatable — bypass the board entirely. Getting your deployment classified as a standard change is the single highest-value conversation available, and it is won with evidence: automated tests, automated rollback, a track record.
- Feature flags separate deploying from releasing (Chapter 13.7), so the code ships in a quiet window and the feature is enabled independently.
- Automated rollback turns "what is your back-out plan" from a paragraph into a command.
And engage with the configuration database. It is frequently out of date and it is what an incident responder reads at 3am. Keeping your service's entry accurate is a small favour that pays back during your own incident.
9. Modernising, when you must
Strangler fig — put a facade in front of the old system, route one capability at a time to a new implementation, and shrink the old system until nothing routes to it. Incremental, reversible per capability, and it is the pattern that actually works.
Anti-corruption layer — a translation boundary so the legacy system's model does not leak into the new one. Without it, the new system inherits the old data model and you have rewritten the legacy system in a newer language.
Read-replica offload — point reporting at a replica or an extracted store, which removes load and risk from the core system without changing it. Often the highest value for the lowest risk, and a good first move.
Event interception — capture changes from the legacy database (change data capture, Chapter 7.3.3) and publish them as events, so new systems consume without the old one being modified. This is frequently the best available integration point with a system nobody may change.
And when not to modernise. A stable system with low change rate, no scaling pressure and no security problem is not a problem to solve. Modernisation should follow a business need — a new capability the old system cannot support, a compliance requirement, an unsupported platform, an unmanageable cost. "It is old" is not a business case, and projects justified that way are the ones that fail.
What the interviewer will push on
"Why do large organisations still run this?" Because it works and it carries the revenue, the business logic is decades of accumulated undocumented rules, rewrites have failed publicly and expensively, and the risk is asymmetric — the upside is cost, the downside is not processing payments. Answering with respect rather than contempt is what the question is testing.
"What is an ESB and would you build one now?" Central routing, transformation and orchestration, solving the N(N−1)/2 integration problem. Today you would decompose it into an API gateway, an event broker and per-service integration — while acknowledging that the problems it solved are real and get rediscovered, which is why service meshes exist.
"How would you integrate with a mainframe you cannot change?" In order: an API over CICS if available, IBM MQ if not, file exchange, and screen scraping only as a last resort. Then add change data capture as event interception, and an anti-corruption layer so its model does not leak into the new system.
"How do you deploy frequently in an ITIL environment?" Get your deployment classified as a standard change by making it evidently safe — automated tests, automated rollback, a track record — and use feature flags so the risky moment is a toggle rather than a deploy. Fighting the process loses; making the change boring wins.
"How would you modernise a legacy system?" Strangler fig with a facade, one capability at a time, behind an anti-corruption layer, starting with read-only offload because it is the lowest risk. And name when not to: "it is old" is not a business case, and modernisation without a business driver is the category of project that fails.
"What is SSIS and why is it still around?" The Microsoft ETL tool, with control flow for task sequencing and data flow for row pipelines, deployed to a catalogue and scheduled by SQL Server Agent. It persists because thousands of packages work and staff know it — and its real weakness is that a visual package is XML that does not diff, so it cannot be reviewed like code.
One thing to volunteer: point out that the on-premises stack table is the cloud shared-responsibility chart with a line drawn across it. It shows you understand the cloud service models as a business arrangement about who operates which layer, rather than as three product names.
Recall
- The stack — application, data, runtime, middleware, OS, virtualisation, servers, storage, network — is exactly the cloud shared-responsibility chart with a line drawn across it. Each layer has a different owner, so cross-layer problems are coordination problems.
- SAN is block over a dedicated network; NAS is a filesystem over SMB or NFS. RAID 10 for databases. Virtualisation gave enterprises live migration, HA and templates first — and a snapshot left in place grows without limit.
- Application servers exist because 2005 applications should not each implement a thread pool and transaction manager. Modern self-contained processes are the container model reached from the other side, and server-held configuration is why these estates resist build-once-promote.
- File shares are still a primary integration channel. Write to a temporary name and rename on completion, because rename is atomic and a reader must not see a partial file.
- An ESB solves N(N−1)/2 integrations and becomes a bottleneck and a single point of failure — which produced decentralised integration, which rediscovered the same needs as gateways, meshes and brokers. EDI and managed file transfer still carry enormous trade volume, and batch windows are a capacity decision.
- Mainframes persist because they work, the logic is undocumented and still in use, and the risk is asymmetric. Integrate via API over CICS → IBM MQ → files → screen scraping, plus change data capture as event interception.
- SSIS: control flow sequences tasks, data flow moves rows. It persists on installed base and non-developer maintainability, and its packages do not diff, which is the real modernisation argument.
- In an ITIL estate, get classified as a standard change by making deployment evidently safe, and use feature flags. Modernise with strangler fig behind an anti-corruption layer, starting with read-only offload — and "it is old" is not a business case.
Self-test: How does the on-premises stack explain IaaS, PaaS and SaaS? · Why write a file under a temporary name first? · What two problems does an ESB create while solving one? · Which mainframe integration point is best, and which is last resort? · What is the difference between SSIS control flow and data flow? · What earns you frequent deploys inside a change advisory process?
Next: 13.10 closes the Part with the certification map — which ones are worth the time, what they actually test, and what they cannot tell an employer.