Whether you're checking your bank account, sending a confidential email or making an API request, TLS is probably working in the background.
You might not think about it, but Transport Layer Security (TLS) plays a vital role in protecting information as it travels across the internet.
However, having TLS enabled doesn't necessarily mean it's configured securely. Which versions are supported? Are outdated protocols still lurking in your infrastructure? And are the right security standards being enforced?
In this Part 1, we'll explore how TLS works, why version and configuration choices matter, and how to manage TLS security across your infrastructure.
Stay tuned for Part 2, where we'll put these principles into practice with a case study: Strengthening TLS Security: Moving Beyond Cloud Provider Defaults.
Let's take a look.
TLS is a cryptographic protocol that provides secure communication between systems.
For example, when you visit a website using HTTPS, TLS helps create a secure connection between your browser and the web server.
It provides three key protections:
TLS can protect all sorts of communications, from websites and APIs to email and other application services.
You will often hear people talk about "SSL certificates" or "SSL configuration".
Technically, modern systems use TLS, not SSL.
SSL, or Secure Sockets Layer, was the predecessor to TLS. SSL 2.0 and SSL 3.0 have long been deprecated because of serious security weaknesses.
TLS was introduced as the successor to SSL and has continued to evolve as security requirements have changed.
So when someone says "SSL certificate", they are usually referring to a certificate being used as part of a modern TLS connection.
The terminology has stuck around, even though SSL itself should not be used.

Without TLS, information sent across a network could potentially be exposed to someone able to intercept the connection.
Imagine logging into your bank and sending your username and password across the internet without encryption.
You would not want that.
TLS helps protect that information through three core principles.
Principle | What it means |
Confidentiality | Keeps transmitted data private through encryption. |
Authentication | Helps verify the identity of the service you are connecting to. |
Integrity | Helps detect whether data has been changed in transit. |
TLS also plays an important role in security and compliance.
Organisations handling sensitive or regulated information may have requirements around encryption in transit, approved cryptographic standards and minimum protocol versions.
So TLS is not just about the padlock you see in your browser.
For many organisations, it is part of the wider security baseline.
So what happens when you connect to an HTTPS website?
Before the application starts sending sensitive information, the client and server need to agree on how they are going to communicate securely.
This is known as the TLS handshake.
At a simplified level, it works like this:
Client → Server: "Here are the TLS versions and security options I support."
Server → Client: "Let's use this version and these security settings. Here is my certificate."
Client: "I'll check that certificate is trusted."
Client ↔ Server: They establish shared session keys.
Client ↔ Server: Encrypted communication begins.
The handshake uses asymmetric cryptography to establish trust and agree on keys, while symmetric encryption is then used to protect the actual data because it is much more efficient for ongoing communication.
The important thing to take away is that TLS is doing considerably more than simply "encrypting the website".
It is establishing a trusted and protected communication channel.

This is where TLS configuration becomes particularly important.
Not all TLS versions provide the same level of security.
These older versions have been deprecated and should no longer be used.
They rely on outdated cryptographic mechanisms and have been affected by various security weaknesses over time.
If they are still enabled on an externally exposed service, it is worth reviewing why.
TLS 1.2 remains widely supported and is commonly used as the minimum acceptable version.
For many organisations, particularly those with regulatory requirements, TLS 1.2 is the baseline.
However, simply enabling TLS 1.2 does not mean every possible configuration is secure. Cipher suites and other cryptographic settings still need to be considered.
TLS 1.3 is the newer version and provides a number of improvements over TLS 1.2.
It simplifies the cryptographic options available, removes a number of older algorithms and improves handshake performance.
It also provides forward secrecy as a standard part of the protocol.
Where supported by your applications and clients, TLS 1.3 is the preferred modern standard.
The general direction is therefore straightforward:
Disable outdated versions and use TLS 1.2 or TLS 1.3.
It can be tempting to think:
"If the connection is encrypted, does the version really matter?"
Yes.
Supporting an outdated protocol can create unnecessary security risk.
It can also create a compliance problem if your organisation is required to enforce a specific minimum security standard.
For example, an organisation may have a policy stating that external services must use TLS 1.2 or higher.
That policy is only useful if the infrastructure actually enforces it.
This is why TLS configuration needs to be tested and monitored rather than simply documented.

Managing TLS for one application is relatively straightforward.
Managing it across dozens of services is a different story.
You might have:
The more services you have, the harder it becomes to manually check every configuration.
This is where consistency becomes important.
You want to know that the same security requirements are being applied wherever they are needed.
Before changing anything, find out what you currently support.
For externally exposed services, you can use tools such as SSL Labs to assess your public TLS configuration.
You can also test individual endpoints using OpenSSL.
For example:
# Check whether TLS 1.0 is accepted
openssl s_client -connect yourdomain.com:443 -tls1
# Check whether TLS 1.3 is supported
openssl s_client -connect yourdomain.com:443 -tls1_3
The first test should fail if TLS 1.0 has been correctly disabled.
The second should succeed if TLS 1.3 is supported.
The important thing is to understand your starting point before making changes.
Once you know what you have, the next step is to define what you actually want.
For most modern environments, that means:
The exact implementation depends on your technology.
For example, NGINX and Apache can be configured to explicitly allow TLS 1.2 and TLS 1.3 while rejecting older versions.
Cloud platforms and CDNs also provide security policies that allow organisations to define the minimum supported TLS version.
The key is to make the requirement explicit rather than relying on whatever happens to be enabled by default.
This is particularly relevant if your infrastructure runs in the cloud.
Cloud providers generally provide default SSL/TLS policies designed to offer broad compatibility.
That makes sense. They need their services to work for a wide range of customers and clients.
But your organisation may have more specific requirements.
A regulated environment, for example, may need:
In those situations, explicitly defining your TLS policies gives you greater control than simply relying on provider defaults.

There is another question worth asking:
How do you make sure these settings stay that way?
Manually configuring a load balancer might solve the immediate problem.
But what happens six months later?
What if someone changes the configuration?
What if you create another load balancer?
What if you need to apply the same security standard across ten more services?
This is where infrastructure as code, such as Terraform, becomes useful.
Instead of manually configuring TLS policies, you can define them in code.
That means your security requirements can be:
It also means that the security configuration becomes part of the platform itself.
Security improvements should not come at the expense of availability.
Increasing the minimum TLS version could prevent older clients or systems from connecting.
That is why changes should be tested before they reach production.
A sensible process is:
Define → Test → Validate → Deploy → Monitor
First, define the required TLS policy.
Then apply it in a staging environment.
Test the application and expected client connections.
Check that deprecated TLS versions are rejected.
Confirm that the correct security policy is being applied.
Once everything has been validated, promote the change to production.
This gives you a controlled way to strengthen security without making changes blindly.

If you are reviewing TLS across your environment, here are some useful questions to ask:
TLS is one of those technologies that should largely be invisible to the end user. But for the people responsible for the platform, it deserves more attention.
Having HTTPS enabled is a good start. It is not the end of the conversation. You also need to consider which TLS versions you allow, which cryptographic policies you use and how consistently those settings are managed.
For regulated organisations, this becomes even more important. Security requirements need to be more than statements in a policy document. They need to be reflected in the infrastructure itself.
Managing TLS through infrastructure as code can help make those requirements consistent, repeatable, reviewable and auditable.
But understanding the principles is only part of the picture. In Part 2, we'll explore how this works in practice through our case study, [Strengthening TLS Security: Moving Beyond Cloud Provider Defaults].
Stay tuned for Part 2, where we'll look at the practical steps involved in strengthening TLS security beyond the standard cloud provider configurations.
At Mesoform, we help organisations build secure and compliant cloud platforms where security requirements are built into the infrastructure and deployment process.
Want to strengthen your cloud security? Contact us.