Why does the SMTP 554 error appear when using a load balancer?

You just sent a batch of transactional emails—everything looked good in the queue—then you get a 554 error: "Missing HELO command." You check your server logs, double-check your DNS, and nothing seems wrong. But the error persists, especially in cloud environments.

Here’s the truth: this isn’t usually a problem with your email content or authentication. It’s often a network layer issue—specifically, a load balancer interrupting the initial SMTP handshake before it even starts. The HELO or EHLO command is the first message in the SMTP conversation. If it never reaches your mail server, the connection is dropped with a 554 error—no graceful fallback, no explanation.

Load balancers in AWS, GCP, or Azure can silently drop early SMTP traffic if they’re not configured to preserve low-level protocol behaviors. They’re built for HTTP/HTTPS, not SMTP’s full handshake. When they act as a proxy or terminate connections too early, the HELO command gets lost in transit.

Key takeaways

  • SMTP 554 errors with "missing HELO command" often stem from load balancer misconfiguration in cloud setups, not email content or DNS issues.
  • Load balancers may drop or rewrite early SMTP traffic if they lack SMTP-aware settings or are not set to preserve the initial HELO/EHLO handshake.
  • Fixing this requires enabling SMTP passthrough, using a TCP-based load balancer, or configuring the load balancer to maintain connection state during the SMTP handshake.

What does 'missing HELO command' really mean in SMTP?

When your email server returns a 554 error for a missing HELO command, it means the connection was initiated without the required initial identification step. HELO (or EHLO) is the first command SMTP clients must send to declare their domain. Without it, the server treats the connection as malformed and rejects it immediately. This isn’t about spam, content, or credentials—it’s a protocol-level handshake failure, often due to misconfigured load balancers, proxies, or connection pooling, even if the sending domain is otherwise valid.

The Role of HELO in the SMTP Handshake

SMTP requires a strict sequence: connect, send HELO/EHLO, negotiate extensions, then deliver mail. The HELO command identifies the sending server’s domain, like “HELO mail.example.com.” This helps servers detect spoofing, track sending behavior, and enforce policies. Skipping it breaks the flow and triggers a 554 error—standard behavior across major providers like Gmail, Outlook, and Apple Mail.

Let’s be clear: this isn’t an email content issue. It’s strictly about infrastructure setup. Your email client or server may be configured to skip HELO if it assumes the load balancer will handle the handshake. But many load balancers don’t forward HELO commands correctly, especially in cloud-native environments with TLS termination at the edge. This breaks the protocol chain before any message data is sent.

According to RFC 5321 (the formal SMTP spec), the HELO command must be sent within the first few seconds of connection establishment: "If the HELO command is not accepted by the receiving server, the sender must not proceed with mail transmission." This is not optional—it’s foundational.

Why Load Balancers Cause This Error

Load balancers sit between your application and the mail server, often handling TLS termination. They may accept the TCP connection and pass data blindly—without ensuring the HELO command is sent on the backend connection. If the backend server requires HELO but never receives it (because the load balancer stripped or lost it), the 554 error is inevitable.

Common causes include: SSL/TLS offloading without preserving the SMTP conversation, misconfigured connection persistence (sticky sessions), or using proxy-based architectures that don't forward the initial handshake. Even some modern cloud email services fail silently if HELO is missing, treating it as an immediate protocol violation.

Fixing it requires ensuring the SMTP handshake completes end-to-end. Check your load balancing configuration, especially if using services like AWS ALB, NGINX, or HAProxy. You may need to adjust how connections are proxied or ensure the backend server receives the HELO command before any mail data.

If you're verifying email lists and running into delivery failures, use a bulk email verification tool to filter out invalid or suspicious addresses before sending. It can reduce the risk of infrastructure issues being masked by poor list hygiene. Validate your entire list upfront to catch problematic domains early.

How load balancers interfere with SMTP HELO handshakes

Application-level load balancers like AWS ALB, NGINX, or HAProxy often block or drop the initial SMTP HELO command because they treat it as non-HTTP traffic and fail to forward it properly. They operate at Layer 7 and may terminate or rewrite TCP streams before the backend mail server ever sees the handshake, causing SMTP 554 errors with "missing HELO command" because the connection was never properly established.

Why HELO gets dropped before it's seen

Load balancers designed for web traffic inspect incoming packets and expect HTTP/HTTPS patterns. The HELO command is an early SMTP signal—usually the first thing sent after a TCP connection—but it doesn’t match typical web protocols, so the balancer may ignore it, queue it, or disconnect the session outright.

This isn’t just theoretical. The SMTP RFC 5321 (specifically section 4.1.1) defines HELO as a mandatory step, but many modern Layer 7 load balancers don’t validate it because they’re not built for mail delivery. The result? The backend server never receives HELO, so it responds with a 554 error stating the command was missing—even though the client sent it.

How load balancers delay or rewrite SMTP traffic

Some load balancers use stream inspection techniques that parse the first few packets before forwarding them. If the HELO command doesn’t match an expected pattern (like a GET or POST request), it can be dropped or delayed beyond the SMTP server’s timeout window.

Even if the connection stays alive, the load balancer may close it before the mail server can complete its side of the handshake. This leads to timing issues where the backend server sees no HELO at all—or one that arrived too late—triggering the 554 error.

You can reduce these issues by using a Layer 4 (TCP) load balancer for SMTP traffic instead of Layer 7, or by configuring the balancer to explicitly allow SMTP commands like HELO, EHLO, and MAIL FROM. Some systems also require a "pass-through" mode for non-HTTP traffic.

For teams managing bulk email sends, validating your list before hitting load-balanced infrastructure helps avoid surprises. Use a service like bulk email verification to catch invalid or risky addresses beforehand, so failed deliveries aren’t buried in complex network errors.

Checklist: Verify HELO support and load balancer configuration

If your mail server logs show SMTP 554 errors with "missing HELO command" right after connection, it’s likely the load balancer is dropping the initial handshake. You need to ensure raw TCP traffic on port 25 (or 587) passes through without rewriting, and that both the load balancer and backend server allow the connection. Check the handshake directly using Telnet, and inspect logs for early drops—this is where the real fix begins.

Configuration and traffic flow

  • Confirm your load balancer is set to Layer 4 (TCP) mode on port 25 or 587, not Layer 7 (HTTP/SSL). SMTP requires raw TCP, not HTTP-based forwarding.
  • Ensure the load balancer is not rewriting, stripping, or sanitizing SMTP handshake messages. Some load balancers interfere with the first few packets, especially if they're configured for HTTP inspection.
  • Verify your backend mail server allows incoming connections from the load balancer’s public IP range. A firewall rule blocking the load balancer’s IP will drop the connection before HELO is sent.

Validation and diagnostics

  • Test the HELO handshake directly using telnet <load-balancer-public-ip> 25. You should see the server respond with 220. Type HELO example.com immediately after—that's where the error typically appears if the connection is being disrupted.
  • Check your mail server logs (e.g. syslog, postfix.log, exim.log) for connection drops that happen right after TCP handshake completes—typically within 1–2 seconds. If no HELO is logged, the load balancer is interfering before the server receives it.
  • For reference, SMTP RFC 5321 specifies that the HELO or EHLO command is required before any other SMTP command. It's a mandatory step—servers that skip it must reject the connection with code 554. See section 4.1.1 of RFC 5321 for the full specification.

When in doubt, try using a public SMTP tester with known good HELO behavior to isolate whether the load balancer is the issue. If the test works from a direct IP but fails through the load balancer, the problem is in the proxy or reverse proxy layer.

How to test if your load balancer is dropping HELO commands

Run a manual SMTP test from your workstation: connect to your load balancer on port 25, wait for the server banner, then send HELO test.example.com. If the connection drops at this point or before, your load balancer is interfering with HELO. Confirm by testing the backend mail server directly—same steps, same IP. If it works there, the load balancer is the culprits.

Step-by-step diagnostic process

  1. Open a terminal or command prompt. Type telnet your-load-balancer-domain-or-ip 25 and press Enter. Replace the domain or IP with your actual load balancer address.
  2. Wait for the server banner response (e.g., 220 mail.example.com ESMTP). This confirms the load balancer is accepting SMTP connections and has a working service.
  3. Type HELO test.example.com and press Enter. This is the critical step: your mail server expects this command to begin the handshake.
  4. If the connection drops immediately after sending HELO—or before you get a response—the load balancer is likely stripping or blocking it. The error code might not appear, but the disconnect is the sign.
  5. Repeat the same test using the backend mail server’s direct IP address (not the load balancer). If HELO works here, the issue is isolated to the load balancer.

What to look for in the response

A successful HELO exchange will return 250 mail.example.com Hello test.example.com [IP]. A dropped connection or a response like 500 Command not recognized after HELO can signal interception.

Step-by-step diagnostic processThe 5 steps described in “Step-by-step diagnostic process”, in order.1Open a terminal or command prompt. Type telnetyour-load-balancer-domain-or-ip 25 and press Enter. Replace the domainor IP with your actual load balancer address.2Wait for the server banner response (e.g., 220 mail.example.com ESMTP).This confirms the load balancer is accepting SMTP connections and has aworking service.3Type HELO test.example.com and press Enter. This is the critical step:your mail server expects this command to begin the handshake.4If the connection drops immediately after sending HELO—or before you geta response—the load balancer is likely stripping or blocking it. Theerror code might not appear, but the disconnect is the sign.5Repeat the same test using the backend mail server’s direct IP address(not the load balancer). If HELO works here, the issue is isolated tothe load balancer.
The 5 steps described in “Step-by-step diagnostic process”, in order.

SMTP RFC 5321 specifies that HELO is mandatory before any mail transaction. If a system fails to send it, the connection should reject it early—but many modern load balancers silently drop it.

You can verify this behavior using tools like RFC 5321, which defines the SMTP protocol handshake. If the load balancer interrupts the sequence, it breaks the protocol stack.

If the test confirms the load balancer is dropping HELO, check its configuration for proxy or ACL rules that strip or block SMTP handshake commands. Some load balancers are set to only handle HTTP/HTTPS traffic and may not be tuned for SMTP.

Fix options for load balancer misconfiguration

SMTP 554 errors with "missing HELO command" often stem from a load balancer intercepting or mismanaging SMTP sessions. If you're using port 25 or 587, switch from HTTP(S) (Layer 7) to TCP-based (Layer 4) load balancing—this preserves the raw SMTP protocol flow. Disable any SMTP inspection, TLS termination, or header rewriting that might strip or alter SMTP handshake messages. Ensure idle TCP connections aren’t dropped before the client sends HELO, which typically requires a timeout of at least 30 seconds. If issues persist, deploy a dedicated SMTP proxy like Postfix with filters behind the load balancer to handle handshakes cleanly.

TCP over HTTP/S: The Layer 4 fix

HTTP/S load balancers (Layer 7) are built for web traffic and often parse, rewrite, or block SMTP traffic, especially during handshakes. If you’re sending email using standard SMTP over port 25 or 587, your load balancer should operate at Layer 4 (TCP). This avoids protocol interpretation altogether and lets the SMTP handshake complete uninterrupted. Layer 4 routing is required for proper SMTP compliance—RFC 5321 specifies that the HELO or EHLO line must be sent early and acknowledged without interference. You can verify your load balancer’s mode in provider documentation like AWS documentation or GCP’s load balancing guide.

Timeouts and proxying: The last mile

Even with correct protocols, many load balancers drop idle connections after 15–30 seconds. SMTP requires the client to send HELO within this window. If the load balancer terminates the connection before HELO arrives, the server returns a 554 error. You can resolve this by adjusting timeout settings or using a fixed connection pool. If your setup still fails, place a reverse proxy like Postfix or Exim in front of the balancer. This proxy handles the HELO/EHLO handshake, TLS negotiation, and connection cleanup independently—giving you full control over SMTP behavior without relying on the load balancer to understand the protocol.

SMTP 554 errors: when they’re caused by sender reputation

SMTP 554 errors with "missing HELO command" aren’t just protocol violations—they can damage your sender reputation. Even if you fix the handshake later, repeated failures from the same IP can trigger blacklists used by Gmail, Outlook, and other major providers. These systems don’t just track email content; they assess server behavior over time, and consistent early-handshake failures signal unreliability.

How handshake failures build reputational debt

You might think a single 554 error is harmless, but repeated instances—especially when tied to one IP address—signal poor infrastructure or misconfigurations. Reputable email platforms like Google and Microsoft use these patterns to gauge sender trustworthiness. An IP that fails the HELO step before sending a message can be flagged as low-reputation, even if the message content later passes SPF, DKIM, and DMARC checks.

It’s not just about the code. If your load balancer or outbound sender is misconfigured, it may drop or misroute the initial SMTP handshake. This isn’t always a bug—it can be a lack of proper HELO header enforcement. The server may send the email, but the failed handshake makes it look like a spammers' tactic to some filters. According to the SMTP RFC, the HELO or EHLO command is required before any DATA command. Skipping it isn’t just non-compliant—it’s a red flag.

Recovery isn’t just configuration—it’s monitoring

Fixing the HELO command is step one. But reputation recovery takes time and consistency. Once an IP earns a negative signal, even clean email sends don’t erase the history. Many providers use Bayesian reputation models that weigh early handshake success against long-term behavior.

Let’s be clear: an email list you send to won’t improve if your sending infrastructure keeps failing at the first layer. That’s why tools that verify sender infrastructure before sending are valuable. For example, using a service like bulk verification helps identify if high bounce rates or delivery issues are rooted in bad infrastructure—or just poor list hygiene.

Don’t assume a working email means a working server. Even valid messages sent from a misconfigured system can carry reputational risk. Audit your email flow—from HELO to deliverability—and treat reputation as a continuous condition, not a one-time fix.

How email verification prevents SMTP errors like 554 in the first place

You prevent SMTP 554 errors caused by missing HELO commands by filtering out invalid, role-based, or catch-all email addresses before sending. These addresses often belong to domains that either reject connections outright or misbehave under load, leading to protocol-level failures like 554. Verifying your list at scale ensures you’re only reaching domains that accept incoming mail and follow SMTP standards.

Invalid and misconfigured domains trigger SMTP failures early

When your email server attempts to send to an address on a domain that doesn’t accept mail—due to misconfiguration, shutdown, or strict filtering—it may drop the connection or reject the handshake. The 554 error with "missing HELO" often surfaces when the server doesn’t get a proper greeting before the connection is dropped. These failures aren’t a problem with your setup—they signal the destination is unreachable or refusing traffic. Sending to such addresses wastes bandwidth and builds sender reputation risk.

Real-time verification stops bad connections before they start

Using a service like Emaillistchecker.io’s real-time API lets you validate each address just before sending. This way, you cut out invalid, role-based (like admin@ or info@), and catch-all addresses—common culprits in SMTP refusal. Catch-all domains often reject messages with non-specific errors, which include 554, and role accounts are commonly monitored or blocked. By eliminating these from the queue, you reduce load on your servers and keep delivery reliable. The bulk verification tool also identifies high-risk domains before sending, so you're not triggering rejections at scale.

Even if your load balancer or mail server is configured correctly, sending to domains that don’t handle SMTP properly will result in a 554 error regardless. That’s why prevention matters more than reaction. The industry-standard SMTP RFC 5321 requires valid HELO/EHLO commands before proceeding—domains that don’t accept those aren’t acting in protocol compliance. Running an email list through a verification system that checks DNS, mail server behavior, and address syntax identifies problematic addresses before they cause delivery failures. This isn’t about improving your mail server—it’s about sending only to destinations that can actually receive mail.

Real-world example: SMTP 554 error after a cloud migration

You migrated your mail server to AWS EC2 behind an Application Load Balancer (ALB), only to hit a 554 error with “missing HELO command” on every outbound connection. The root cause? The ALB was misconfigured to route port 25 as HTTP, which terminates SMTP connections before the HELO handshake completes. Switching the listener to TCP pass-through mode on port 25 restored the SMTP handshake and fixed the error immediately.

What the error actually means

The SMTP 554 error with “missing HELO command” is not about invalid headers—it means the server dropped the connection before the handshake finished. This often happens when a load balancer or proxy doesn’t support SMTP at layer 4, instead treating it as HTTP traffic and closing the socket after the first command.

When you test with telnet, you might see the connection drop right after sending HELO or EHLO. That’s not a problem with your mail client—it’s your network stack intercepting and breaking the SMTP protocol early. The server never sees the HELO, so it rejects the session outright.

Why the ALB was the culprit

By default, ALBs are designed for HTTP/HTTPS traffic. They inspect the payload and can’t handle raw SMTP data. When port 25 is configured under “HTTP” or “HTTPS” listeners, the ALB interprets the incoming stream as HTTP, responds with a 400 error, and disconnects—before your SMTP client even says HELO.

The fix isn’t in your mail server config. It’s in the load balancer. You need to set up a TCP listener on port 25 instead of relying on HTTP mode. This forces the ALB to pass through the raw TCP stream without interpretation.

According to RFC 5321 (which defines SMTP), the HELO command is the first required step in the handshake. If the server never receives it, the session fails. Misconfigured load balancers disrupt this early step, even if everything else—authentication, TLS, DNS records—is perfect.

Once you switch to TCP pass-through, your mail server can exchange HELO and begin the validation process. The 554 error disappears, and your messages begin delivering reliably. This isn’t a fix you can skip by adjusting DNS records, SPF, or DKIM—it’s a transport-layer issue, not a deliverability one.

If you're managing email delivery in a cloud environment, tools like the bulk email verification service can help you identify and clean invalid addresses before they trigger deliverability issues—ensuring your SMTP stack is efficient from the first byte of the handshake.

Maintaining deliverability post-fix: what to monitor

Fixing the SMTP 554 error caused by a missing HELO command on your load balancer is the first step. Now, verify that your infrastructure consistently sends valid HELO/EHLO greetings in every SMTP session.

Monitor sender reputation using tools like MxToolbox or Spamhaus. Check mail server logs for recurring bounce rates and error codes, especially 554, 550, or 4xx responses tied to authentication or envelope issues. These signals help detect configuration drift or misconfigured load balancer proxies before they impact deliverability.

Validate inbox placement with a delivery test tool after the fix. Confirm that messages reach inboxes reliably, not just bounces. Ensure your domain has properly configured SPF, DKIM, and DMARC records to prevent secondary rejections, even when the initial handshake is successful.

Keep reading

Ready to put this into practice? Emaillistchecker.io verifies emails with 98.9% accuracy — start with 100 free verifications.

Frequently asked questions

What is the HELO command in SMTP?

HELO is the first command a mail client sends to identify itself to the mail server. It is required by the SMTP protocol before any email data can be sent.

Why does a load balancer cause 'missing HELO' in SMTP?

Load balancers that operate at Layer 7 (HTTP/S) may not pass through early SMTP handshake commands like HELO if they are not recognized as valid HTTP traffic.

Can a misconfigured mail server cause SMTP 554 errors?

Yes, if the server fails to respond to HELO or rejects the command due to strict filtering or incorrect configuration.

Is the 554 error always a send-side issue?

No—the 554 error indicates a client-side command failure, but often stems from intermediate infrastructure like load balancers or firewalls.

Does Emaillistchecker.io help with SMTP 554 errors?

It doesn’t fix network misconfigurations, but verifying your list reduces sends to domains likely to reject connections due to invalid or unresponsive addresses.

How do I test if my mail server is receiving HELO commands?

Use Telnet to connect to port 25 or 587 and manually send HELO. If the command drops, the issue is likely in the network path.

What load balancer settings fix HELO issues?

Use TCP pass-through (Layer 4) instead of HTTP/S (Layer 7) routing, disable SMTP rewriting, and ensure no timeout is set shorter than 30 seconds.

Can sending to role accounts cause SMTP 554 errors?

Role accounts (e.g., sales@) may have strict filtering but do not typically cause missing HELO errors. The issue is usually network or configuration-based.

Is there a way to avoid 554 errors without changing load balancers?

Yes—use an SMTP proxy or forwarder in your trusted network that handles HELO handshakes securely before relaying messages.

How often should I test for SMTP delivery issues?

Test at least once after infrastructure changes, and regularly (e.g., monthly) using a deliverability testing tool to catch issues early.