Skip to content
IT & API security

200-Day TLS: Automating ERP Interface Certificates

Since 15 March 2026 TLS certificates last 200 days, from 2027 just 100, from 2029 only 47. How ERP interfaces renew certificates automatically, not by hand.

14 min read TLSZertifikatemTLSACMEBetriebSchnittstellen

Since 15 March 2026, publicly trusted TLS certificates may be valid for no more than 200 days (CA/Browser Forum, Ballot SC-081v3). The day before, the limit was 398 days (CA/Browser Forum, Baseline Requirements). On 15 March 2027 the ceiling drops to 100 days, and on 15 March 2029 to 47 days (CA/Browser Forum, Ballot SC-081v3). For the online shop this is usually a solved problem: web servers and hosting providers have been renewing certificates automatically for years. For the interfaces behind the shop, that is far less common. There, certificates sit in truststores, in middleware configurations, in client certificates for mTLS and in legacy systems that stay untouched for years. This article describes how the certificate lifecycle becomes an operating discipline – and how interfaces between ERP and shop can renew themselves instead of hanging on an annual calendar reminder.

Key takeaways

  • Since 15 March 2026 publicly trusted TLS certificates may last no longer than 200 days, down from 398 days; 15 March 2027 brings 100 days and 15 March 2029 brings 47 days plus domain validation reuse of only 10 days (CA/Browser Forum, Ballot SC-081v3).
  • Four places break in a shop-to-ERP landscape: the ERP API server certificate, the client certificate used for mTLS, outdated truststores and CA bundles, and certificate pinning inside connectors. These four usually sit with four different owners.
  • An expired certificate fails silently on an interface: the TLS handshake breaks before any HTTP request is formed (IETF RFC 8446). Storefront and checkout keep working, orders pile up in retry queues, and duplicates threaten once the link is fixed.
  • Automation runs on ACME per IETF RFC 8555 for public endpoints and an internal CA for mTLS, using a service reload instead of a restart and an overlap window of roughly 30 days (project experience). RFC 9773 randomizes renewal timing.
  • The certificate inventory records per connection: endpoint and purpose, certificate type, issuer, expiry, a named owner, the renewal path and a test endpoint (NIST SP 1800-16). Active checks warn at 30 days and escalate at 7 days remaining.
  • Beyond your own automation sit truststores in customer systems, Java keystores, hardcoded CA bundles in script connectors and copies inside container images. The German BSI recommends TLS 1.3 through 2032 and TLS 1.2 only until end of 2031 (BSI TR-02102-2).

What actually changed on 15 March 2026

The CA/Browser Forum is the body in which certification authorities and browser vendors define the Baseline Requirements for publicly trusted certificates. Ballot SC-081v3 introduced a staged schedule that reduces the maximum lifetime of server certificates in three steps and shortens the reuse period for domain validation data in parallel (CA/Browser Forum, Ballot SC-081v3). The first step has been in force since 15 March 2026. Anyone obtaining a certificate from a public certification authority today receives it with a maximum lifetime of 200 days (CA/Browser Forum, Ballot SC-081v3) – regardless of what the ordering process allowed in the past.

The second stage follows on 15 March 2027 with 100 days, the third on 15 March 2029 with 47 days (CA/Browser Forum, Ballot SC-081v3). Measured against the 398 days that applied until 14 March 2026 (CA/Browser Forum, Baseline Requirements), that is a reduction by a factor of roughly eight and a half. For a single web server this is a configuration question. For a grown integration landscape with an ERP system, middleware, marketplace connections and logistics partners, it is a process question.

Effective dateMaximum certificate lifetimeDomain validation data reuse
until 14 Mar 2026398 days398 days
from 15 Mar 2026200 days200 days
from 15 Mar 2027100 days100 days
from 15 Mar 202947 days10 days

The third column is frequently overlooked, yet it has the larger operational effect. By 2029, the period within which a completed domain and IP validation may be reused drops to 10 days (CA/Browser Forum, Ballot SC-081v3). In practice this means that from that stage onwards, almost every renewal also triggers a fresh control check over the domain. Anyone still performing that validation manually via a DNS record or a file on the web server will, from 2029, permanently tie staff to a task that can be fully automated.

What "publicly trusted" means – and what it does not

The deadlines apply to certificates from public certification authorities whose roots live in the trust stores of browsers and operating systems. Certificates from your own internal certification authority are formally out of scope. In practice most operators adopt the short lifetimes anyway, because the same automation serves both cases and short-lived certificates shrink the window for misuse. For the selection of cryptographic methods themselves, the German reference point is the BSI technical guideline TR-02102-2 (BSI TR-02102-2).

A simple back-of-the-envelope calculation shows why the manual model no longer holds. At 398 days, one appointment per year and endpoint was enough. At 200 days it is two, at 100 days four, and at 47 days roughly eight to nine (CA/Browser Forum, Ballot SC-081v3). A mid-sized commerce landscape with a shop, an ERP system, middleware, two marketplace connections, a shipping provider and a payment reconciliation quickly reaches 15 to 25 TLS endpoints (project experience). By 2029, twenty calendar appointments per year turn into roughly 170 – spread across teams, service providers and systems, some of which are not even in your own data centre.

A calendar entry does not scale with the schedule

A reminder in a calendar is a method for rare events. As soon as a task occurs more than a dozen times a year, it behaves like an operating process: it needs a defined trigger, an automated sequence, a verification of the result and an escalation path when something does not complete. Those four elements are precisely what is missing for most certificates attached to ERP interfaces today.

Four places where the shop-to-ERP landscape breaks

Searching an integration path for certificates turns up more of them than expected. A call from the shop to the ERP system usually traverses several TLS connections, and each one has two sides. In a classic connection between SAP and the shop that quickly adds up to four to six hops. Four places fail particularly often in practice.

Server certificate of the ERP API

The certificate the interface presents to the shop or the middleware. It is the most visible case and usually the only one that appears on a renewal list at all.

Client certificate for mTLS

With mutual authentication the caller also identifies itself with a certificate. Once it expires, the far side rejects the connection – without anything looking unusual on your own server.

Truststore and CA bundle

Both sides have to trust the issuing certification authority. Outdated root certificates or a frozen CA bundle break the connection even though the server certificate is fresh.

Certificate pinning in the connector

Older connectors sometimes verify a hard-wired fingerprint. After a certificate swap the fingerprint no longer matches and the connection fails despite a valid chain.

These four places rarely sit in the same area of responsibility. The server certificate is often handled by the hosting provider, the client certificate by the integration team, the truststore by system administration and the pinning by the vendor of the connector. Once a 47-day lifetime applies, those four responsibilities have to work in a rhythm they have not known so far. How closely technical hardening and accountability are linked is also covered in our article on securing ERP interfaces to NIS2 standards.

Pinning is the quietest trap

Certificate pinning was introduced to make attacks via substituted certificates harder. With an annual swap the maintenance effort was manageable. At 47 days, a connector pinned to the end-entity certificate becomes a scheduled failure: it breaks predictably at every renewal. Where pinning still makes sense, the anchor belongs on your own internal certification authority or on a public key with a long lifetime – not on the short-lived end-entity certificate.

Why an expired certificate fails silently in the ERP

In the shop, an expired certificate is a loud event. The browser shows a warning page, customers get in touch, and the incident is known within minutes. On the ERP side that alarm does not exist. No browser talks to the interface there – a connector, a middleware or a nightly job does. If the certificate chain fails validation, the TLS handshake aborts before an HTTP request even exists. The application does not see an error code from the ERP system, it sees a connection error at transport level.

That difference is exactly what makes the outage dangerous. In the standard configuration, TLS 1.3 requires the server to authenticate with a certificate (IETF RFC 8446); if that fails, the connection ends before the application logic above it ever starts. For an order system this means the order has been accepted, paid for and confirmed in the shop – it simply never arrives in the ERP system. Depending on the architecture, the orders end up in a retry queue, in a dead-letter queue or in a log file that is opened at the next scheduled look.

  • No user feedback: the abort happens between two machines. The shop stays usable, checkout works, the confirmation email goes out.
  • Filling retry queues: repeat attempts keep running and create load without solving anything – the error is not transient, it is structural.
  • Delayed visibility: the outage often surfaces through secondary symptoms: missing order numbers, stock levels that stop moving, a shipping run without a data basis.
  • Duplicate processing after the repair: once the connection is fixed, every queued message arrives at once. Without idempotency keys, duplicates are created in the process.
  • Opaque error messages: entries such as "certificate verify failed" or "handshake failure" land in the system log, not in the business process – and are rarely read there.

In the shop, an expired certificate reports itself to the customer. In the interface, it reports itself at the month-end close.

ERP Integration Agency

Certificate expiry therefore belongs in the same category as any other disruption of the transfer path. How queued messages can be reprocessed cleanly without creating duplicates is described in our article on idempotency and retry strategies; the question of which signals an interface should emit in the first place is covered in the piece on observability and monitoring for interfaces. For classifying transport errors against business errors, the article on error handling in interfaces is worth a look as well.

Automation: ACME, an internal CA and rollover

For public endpoints the path is standardised. The Automatic Certificate Management Environment, specified in IETF RFC 8555 (March 2019), describes a protocol with which a client handles domain validation, issuance and renewal without human involvement (IETF RFC 8555). The specification names as its starting point that operators typically need one to three hours to obtain and install a certificate (IETF RFC 8555) – multiplied by eight renewals a year across twenty endpoints, that is where the actual cost sits.

ACME for public endpoints

The externally reachable interface renews its certificate through the ACME protocol per RFC 8555 – including the domain validation that, from 2029, is due at almost every run.

Internal CA for mTLS

Machine-to-machine connections between ERP, middleware and shop run through your own certification authority. It issues short-lived client certificates measured in days rather than years.

Reload instead of restart

After the swap, the service reloads key and chain while running. A restart would drop open connections and turn a routine task into a maintenance window.

Renewal run per endpoint (condensed)
1  Determine remaining lifetime  -> below the threshold?
2  Request a new certificate     -> ACME (RFC 8555) or internal CA
3  Place key + chain on disk     -> atomically, old files retained
4  Reload the service            -> no restart, no dropped connections
5  Call the test endpoint        -> verify handshake, chain and expiry
6  Report the result             -> log success, escalate failures
7  Remove the old certificate    -> only after a successful test

One detail decides whether the automation stays calm in daily operation: the timing of the renewal. The ACME renewal information extension, specified in IETF RFC 9773 (June 2025), lets the issuing authority suggest a renewal window from which the client picks a random point in time (IETF RFC 9773). This prevents every endpoint from renewing in the same hour and gives the certification authority room to act when certificates have to be replaced outside the normal schedule (IETF RFC 9773).

An overlap window instead of a big-bang swap

A certificate change should not be a cut-off date but a transition. In practice a window of about 30 days works well (project experience): the new certificate is generated and distributed while the old one is still valid. Truststores on the far side receive the new chain in advance, connectors are checked against the test endpoint, and only then does the switch happen. If a step fails, the existing connection remains usable – instead of blocking every order for a night.
AspectBig-bang swapRollover with overlap
Timingone cut-off date for all systemsstaggered window per endpoint
Fallbackrestore from backup onlyold certificate stays valid until the test
Truststore upkeepat the same time as the swapnew chain distributed in advance
Verificationin productionthrough a dedicated test endpoint
Impact on failureorder path breaksthe switch is postponed
Operating modemaintenance windownormal operation

The certificate inventory as an operating artefact

Automation presupposes knowledge. A renewal job can only serve what is documented. In its practice guide SP 1800-16, "Securing Web Transactions: TLS Server Certificate Management" (June 2020), NIST describes exactly this connection: a formal certificate management programme should put organisations in a position to prevent, detect and recover from certificate-related incidents (NIST SP 1800-16). The first building block of such a programme is a complete inventory, the second a clear assignment of responsibilities (NIST SP 1800-16).

  • Endpoint and purpose: which host, which port, which business path – order transfer, stock reconciliation or invoice export, for example.
  • Certificate type: server certificate, client certificate for mTLS, or a root or intermediate certificate in the truststore.
  • Expiry date and issuer: valid until when, issued by which authority, publicly trusted or from the internal certification authority.
  • Owner: a named role inside the company – not a shared mailbox that in case of doubt reaches everyone and therefore no one.
  • Renewal path: automated via ACME, via the internal CA, or manually with a service provider – with the specific trigger and lead time.
  • Test endpoint: the address at which handshake, chain and expiry date can be verified after the swap without touching the production flow.

The second part is active verification. Monitoring that only fires on a connection error reports the outage – not the cause, and certainly not in time. What works is a dedicated check that performs the handshake regularly, reads the remaining lifetime and raises an alert below a threshold. A two-stage threshold has proven useful: an early warning at 30 days remaining and an escalation at 7 days (project experience). With a 47-day lifetime from 2029, the early warning moves close to the renewal itself – another reason not to run the process by hand.

Response of an active certificate check
{
  "endpoint": "erp-api.example.com:443",
  "purpose": "order transfer shop -> ERP",
  "issuer": "public-ca",
  "not_after": "2026-10-15T09:12:00Z",
  "days_remaining": 78,
  "warn_days": 30,
  "critical_days": 7,
  "chain_complete": true,
  "client_cert_days_remaining": 21,
  "status": "warn",
  "owner": "integration-operations"
}

The check belongs on both sides

A certificate check that looks only at your own server certificate misses half the failure modes. It should also cover the client certificate your middleware uses to identify itself to the ERP system or the logistics partner, and the completeness of the chain being served. An incomplete chain often works for months because one system has cached the missing intermediate certificate – and then fails on a freshly installed server. How such constellations can be reproduced in advance is described in our article on test environments and test data for ERP interfaces.

Special cases: customer systems, keystores and connectors

The awkward cases are the ones where the certificate is not under your control. In B2B commerce there are regularly connections whose far side is operated by the customer or a service provider: a procurement portal fetching catalogues over mTLS, a freight system receiving status messages, or a data centre hosting the inventory system of a corporate customer. Here your own automation only reaches as far as the boundary – the rest is coordination, and coordination needs lead time.

  • Certificates in customer systems: the customer has to install the new chain in their truststore. A lead time of several weeks and a named technical contact on both sides are the actual safeguard here.
  • Service providers without automation: some partners still exchange certificates by ticket. In that case the procedure, its lead time and its escalation path belong in the contract or at least in the operating agreement.
  • Java keystores: trust anchors live in JKS or PKCS 12 files, often next to the application and outside any package management. Without an inventory, such a store stays untouched for years.
  • PHP and script connectors: here the configuration frequently points to a hard-wired CA bundle. If the bundle is not maintained alongside, validation fails even though both certificates are valid.
  • Embedded copies: container images and legacy installations sometimes carry their own copy of the trust store. They are only updated at the next rebuild – which may not be scheduled at all.

The same principle applies to Java keystores and script connectors as to everything else: the trust anchor belongs in the inventory, with file, path, contents and owner. A truststore is not a static artefact but a configuration with a lifetime. The practical consequence is unspectacular and effective at once – the place where an application reads its root certificates is set explicitly, versioned, and served by the same automation as the server certificate. How such operational decisions can be documented in an auditable way is shown in our article on process documentation for ERP-to-shop interfaces.

That leaves the question of pinning. It remains sensible where a connection crosses a network you do not trust and where the far side is stable – a fixed link to an internal system across a third-party network, for instance. The anchor then belongs on the internal certification authority or on a public key that outlives the certificate swap. Pinning to the end-entity certificate was already laborious at 398 days; at 47 days it becomes a task that forces manual work eight or nine times a year. Strengthening authentication at application level achieves more: a token bound to its sender, as described in our article on OAuth 2.0 and token security, also protects when the transport layer is renegotiated.

A second look at the cryptography itself is worthwhile. In the current edition of technical guideline TR-02102-2 (version 2026-01 of 27 January 2026), the BSI recommends TLS 1.3 with a usage horizon up to 2032 and beyond, while TLS 1.2 is only recommended until the end of 2031 (BSI TR-02102-2). As minimum key lengths the guideline names 3000 bits for RSA and 250 bits for ECDSA and ECDH, aimed at a security level of 120 bits (BSI TR-02102-2). The prediction horizon for these recommendations is seven years (BSI TR-02102-2). Against that backdrop, short lifetimes are not an end in themselves: they are the precondition for changing cryptographic methods without touching every interface individually – an advantage that will count at the latest during the move to quantum-safe key agreement (BSI TR-02102-2).

What this means for your interfaces

The road from calendar entry to operating process can be walked in four steps, and it depends less on tooling than on clarity. Almost all the effort sits in the first step: once the inventory exists, the rest is routine. In a typical landscape with middleware between shop and ERP, this covers the connections to the inventory system, to marketplaces, to shipping providers and to payment reconciliation.

1. Build the inventory

Record every TLS connection along the integration path: endpoint, certificate type, issuer, expiry date, owner. Truststores and client certificates explicitly belong on that list.

2. Define the renewal path

Decide per endpoint whether renewal runs via ACME, via the internal certification authority or in coordination with a partner – with a lead time and a named role.

3. Automate rotation and reload

Set up renewal, distribution and reloading without a restart, with an overlap window and a test endpoint that confirms the handshake after the swap.

4. Arm the expiry alert

Actively check the remaining lifetime on both sides of the connection, with an early warning and an escalation – so the alert arrives before the outage, not after it.

Two current developments add further pressure, because they introduce new external endpoints into the landscape: the reporting duties around packaging data under the PPWR and the changed data requirements of the customs reform for ERP and shop. Every additional connection to an authority or partner system is another TLS connection with its own certificate, its own truststore and its own ownership. Without an inventory, that list grows faster than it is maintained – which connections we look after is set out in the overview of our ERP integration services.

A certificate is not a document you file away. It is an expiry date you operate.

ERP Integration Agency

Sources and studies

This article is based on data from: CA/Browser Forum, Ballot SC-081v3 and the Baseline Requirements for the Issuance and Management of Publicly-Trusted TLS Server Certificates (sections 4.2.1 and 6.3.2, staged schedule for 15 March 2026, 15 March 2027 and 15 March 2029); BSI, technical guideline TR-02102-2 "Cryptographic Mechanisms: Recommendations and Key Lengths, Part 2 – Use of Transport Layer Security (TLS)", version 2026-01 of 27 January 2026; IETF RFC 8555 (Automatic Certificate Management Environment, ACME, March 2019); IETF RFC 9773 (ACME Renewal Information Extension, June 2025); IETF RFC 8446 (The Transport Layer Security Protocol Version 1.3, August 2018); NIST Special Publication 1800-16 "Securing Web Transactions: TLS Server Certificate Management" (June 2020). Complemented by our own project experience from ERP-to-shop integrations. The deadlines and values cited may change with future editions of the underlying rule sets.

Related Articles

ERP & merchandise management

Units of Measure and Pack Sizes from ERP to Your Shop

Separate base, stock, selling and purchase units, pull conversion factors from the ERP, and map stock, minimum quantities and unit prices correctly.

13 min read
APIs, middleware & architecture

ERP Outage: Keeping the Shop Selling in Fallback Mode

Absorb an ERP outage: last valid stock and prices with an age stamp, buffered orders, conservative checkout rules and an orderly, deduplicated restart.

13 min read
ERP & merchandise management

SAP ECC Maintenance Ends 2027: Migrate Shop Links

SAP ECC maintenance ends on 31 Dec 2027. Every ECC-coupled shop connector must move to S/4HANA. How to plan the migration path without shop downtime.

11 min read