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 date | Maximum certificate lifetime | Domain validation data reuse |
|---|---|---|
| until 14 Mar 2026 | 398 days | 398 days |
| from 15 Mar 2026 | 200 days | 200 days |
| from 15 Mar 2027 | 100 days | 100 days |
| from 15 Mar 2029 | 47 days | 10 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
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
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
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.
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.
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 testOne 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
| Aspect | Big-bang swap | Rollover with overlap |
|---|---|---|
| Timing | one cut-off date for all systems | staggered window per endpoint |
| Fallback | restore from backup only | old certificate stays valid until the test |
| Truststore upkeep | at the same time as the swap | new chain distributed in advance |
| Verification | in production | through a dedicated test endpoint |
| Impact on failure | order path breaks | the switch is postponed |
| Operating mode | maintenance window | normal 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.
{
"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
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.
Sources and studies
Related Articles
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.
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.
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.