Your suppliers each play their own game - you pay the price

Last week I was with our newest client. A company of 500 employees, do international business and it is important to them that all IT runs without a hassle. There I told about a certain way of organizing your architecture. His reaction - besides big eyes and enthusiasm: you should write about that, more companies should know about this. Here goes!

Look, outsourcing IT sounds smart. And it often is. Let specialists do it - they can do it better, faster and often cheaper than you can ever organize yourself. So it makes sense that more and more companies are outsourcing their IT to external suppliers.

But ...

The more specialists tinker with your IT landscape, the more complex it becomes. After all, no single party can do everything. Before you know it, you will have a whole tribe {I would find “herd” a nice word too but you want people to connect with you here, so better choose a neutral word that they recognize, “hey I have that too!” eg collection/group/row} of vendors: one club for your network, one for the cloud, one party for your software development, another for cybersecurity....

And all of them promise to have your best interests at heart.

Only ... the question that really needs to be asked and answered: how well do they work together?

Because that's where the bottleneck is. IT doesn't stop at one vendor's contract. It's the lines between them that determine whether your operations run smoothly or grind to a halt. That firewall set up by vendor A, does it work well with vendor B's monitoring? Who makes sure the application built by C performs well on D's platform? And if something goes wrong - who picks it up?

Without clear governance and smart standards, you end up being the one to glue things together. Because those vendors don't address each other, they address you. And then ‘cheap’ solutions suddenly become surprisingly expensive.

And in 9 cases out of 10, it is surprisingly easy to do it differently.

Overlap and Swiss cheese

The better you agree on the rules of the game in advance, the less you have to put out fires afterwards. This starts with governance: you determine what the playing field looks like. Not your suppliers.

Applications and services rarely fit together seamlessly. Not even if they come from the same supplier. They often overlap in functionality - think of two systems that both do user management or logging, each in their own way. Or just that one essential piece of functionality that isn't invested anywhere. The result: an IT landscape that resembles hole cheese, with a tuft of overlap here and there and holes everywhere that no one is responsible for. And hole cheese . costs money, lots of money.

And what specifically does that mean?
That different employees do the same thing with different software, without anyone noticing. Or that crucial tasks remain unfinished because each supplier assumes that they will be taken care of by someone else. 

Monitoring is a good example of this: some only look at their own piece, while others rely on signals from another layer. Until you have a problem somewhere in the stack that everyone overlooks.

And then the game of “who is responsible?” begins.

Hint: usually it's you. {or just: that's you}

You can't leave this kind of tuning to your vendors. After all, they only see up to the limits of their own contract. Why would they do otherwise? They have no incentive to monitor the bigger picture - you do.

And that's why it's your job. Without tight governance and clear standards, things go wrong. Minor technical differences pile up into major operational problems. And the costs? They rise invisibly along with them.

How many hoops is your data jumping through?

A simple Web app database chain seems uncluttered. But that's rarely what it looks like in a mature organization. Applications rarely stand alone; they need data and functionality from other systems. They validate users through a central authentication system, retrieve customer data from a CRM, check credit limits in an ERP, and store transactions elsewhere again.

Before you know it, one simple request goes through a dozen layers. Why is that a problem? Each system does its own work, adding a fraction of a second - or more. And those delays accumulate unnoticed. Until the user at the front end has to wait a second or two. Or three. And we all know: the longer that takes, the sooner he quits or calls your help desk.

It gets even more annoying when those layers are spread across different physical locations. A piece of middleware running in a data center in Frankfurt, a CRM in Amsterdam and an authentication service in Dublin. Each request crosses country borders multiple times, entire networks and dozens of routers. That's inherently slower than running locally - even with good connectivity. And I'm talking about systems within Europe ...

The problem here? No one feels responsible for the overall picture. The networking club says their line is running fine. The database team points to query time. The application builder claims his code is nicely optimized. And so you end up with the complaints on your plate, with no clear indication of where the biggest bottleneck is.

And I am not making this up. This is what I experience every day at companies. Large companies, large and small SMEs.

Shared infrastructure: unfortunately it's the recipe for delay

All those applications and management solutions you buy end up running together on the same infrastructure. Your network, your servers, your storage - that's the common foundation. But do those applications actually know what the other is doing?

Rarely. They run happily side by side, often without any awareness of each other's impact. Until suddenly they start competing for the same resources. A backup that starts while your ERP is just peaking. Monitoring tools that generate so much traffic that they themselves cause delays. Or a patch cycle that brings down half the network.

The result: systems that unintentionally get in each other's way. And a business that suffers directly as a result.

And we all know: delays cost an awful lot of money. Because time = money, especially in IT environments.

Technical governance: the silent force under your IT (or your biggest cost)

Governance is not an unfamiliar concept to most companies. You make strategic choices, set out processes, determine who is responsible. But what about directing the technical layer of your IT landscape?

That's where things often go wrong. Technical management is a neglected child. While that is precisely where the basis lies for all your applications to run and work together. If that layer is not properly tuned, nothing really works together. An application that needs specific database versions, a security tool that does not match your hypervisor, monitoring that paralyzes half of your network - small technical differences pile up into big problems.

It doesn't just affect your performance. A lack of technical governance can also hurt you financially. Just look at licenses: vendors give big discounts if you buy larger volumes. But you only get those economies of scale if you standardize. If you buy something slightly different everywhere, you end up with all sorts of individual contracts. Separate contracts deliver exactly what you don't want:

• are more expensive each

• cause additional management costs

• complicate negotiation

Without governance, everyone continues to optimize for their own piece. One department chooses Oracle because their vendor is handy with it, the other chooses Microsoft SQL because they have "always worked with it. The result? Fragmentation, higher costs and an IT environment that becomes viscous and vulnerable.

Technical governance means that you set frameworks: which platforms, which versions, which tools. That you determine what standardization looks like, so that applications integrate more easily, your costs are lower and you can switch faster. It may not be the most exciting part of IT - but it prevents your landscape from turning into a costly patchwork quilt full of incompatibility and missed discounts.

In short: those who manage technology reap double the benefits - in performance and in dollars.

The Fractional Architect: your technology in order, without a full cost

Technical governance and architecture are not full-time positions at most companies. Logical - such a specialist is expensive and often not needed every day. But the field is so complex that you can't just let a system administrator or IT manager do it ‘on the side’.

This is exactly what I said to the man who asked me to write this blog: That is why we have fractional technical architects at Sciante. They set the lines for your company, monitor consistency and keep your technology tightly tuned - without costing you a complete FTE. This gives you all the benefits of professional technical governance: an IT landscape that works, economies of scale through standardization, and fewer risks. But without the high costs of a full-time architect.

Wondering what that looks like for your organization?

Schedule a no-obligation consultation with me right away. I guarantee you'll get excited during that conversation and together we'll look at how your organization can organize technology smartly.

Book your appointment here

Click Me