Semitexa can use Server-Sent Events (SSE) to send either named data events for browser-side handling or completed server-rendered HTML for a deferred page region. SSE is a one-way server-to-browser stream over HTTP: a page can start work with an ordinary request, then listen for progress or results. Which pattern fits depends on whether the browser needs to interpret the update or the server already owns the markup.
What SSE does—and what it does not do
SSE keeps an HTTP response open so a server can send a sequence of text events to a browser through the EventSource API. The response uses Content-Type: text/event-stream. Communication on that stream is one-way, from server to browser; it is not a replacement for requests that start or change work. A common flow is for the page to submit a normal HTTP request to begin a job and then receive progress events on an SSE connection. See the WHATWG server-sent events specification and MDN’s browser API overview.
SSE is a protocol and browser API, not a rule that messages must contain JSON or HTML. JSON is a common convention for data events; a server can also send rendered markup when the application’s design calls for it. Semitexa’s deferred-region flow is a framework-specific use of the transport, not a standard SSE endpoint or browser feature.
How an SSE event is framed
An event stream is UTF-8 text. Its fields are written one per line, and a blank line ends the event and allows the browser to dispatch it. The protocol’s common fields are:
#1 Best Overall
datacarries the message content. Multiple data lines are joined for dispatch.eventgives an event a custom name, which browser code can use to register a specific listener.idsets the event ID that the browser can report when reconnecting.retrysupplies a reconnection delay in milliseconds.
A line beginning with : is a comment rather than a dispatched event; it can be used as a heartbeat. The framing rules and reconnection behavior are defined by the WHATWG specification. MDN also provides a browser and PHP implementation guide.
Choose between named data and deferred HTML
Named events when browser code interprets the update
Use named events for progress, notifications, or state changes that the client needs to interpret. For example, Semitexa’s examples use names such as notification and scheduler.tick. The browser can listen for the event name, parse its data—often JSON—and update the relevant interface. This is a good fit when client behavior depends on the meaning of the message, such as displaying progress or responding to a status change.
Rank #2
Deferred HTML when the server owns the region
Use deferred HTML when the server already owns the region’s markup and can render it. Semitexa describes sending an initial page shell with a placeholder or skeleton, then delivering a completed server-rendered region into that placeholder. Its examples use Twig templates and the Semitexa-specific /__semitexa_kiss stream. That route is part of Semitexa’s described architecture; it is not a general SSE URL convention. The framework presents deferred regions alongside live transport, so a page can render useful initial HTML, receive a completed region later, and continue receiving updates. The architecture described in the Semitexa streaming guide is for its PHP/Swoole runtime and server-rendered Twig views; its capacity and runtime behavior are not independently established here.
The practical distinction is ownership: send data when browser code must decide what to do with it; send rendered HTML when the server should produce the region and the client only needs to place it. Keep the initial response useful where possible rather than making the entire page wait on a deferred region.
How to decide among SSE, WebSockets, and polling
Choose based on communication direction, payload, update frequency, acceptable delay, and how the application will recover state—not on a blanket claim that one transport is always best.
| Option | Communication and payload | When it may fit | Recovery consideration |
|---|---|---|---|
| SSE | One-way server-to-browser text events. | The browser sends a command separately and mostly listens for server updates. | Reconnect behavior alone does not restore missed application updates; implement replay or fetch a current snapshot. |
| WebSockets | Two-way interaction; supports binary messages. | Frequent communication in both directions or binary traffic is needed. | Define application-level recovery and state synchronization for the chosen design. |
| Polling | Repeated client requests for current information. | Changes are infrequent and the delay between checks is acceptable. | Each request can retrieve current state, but the application must choose an interval and handle stale responses. |
These are trade-offs, not performance guarantees. Assess them under the actual workload and delivery path. Semitexa’s overview discusses SSE alongside WebSockets and polling.
Rank #4
What PHP developers need to check in the delivery path
Writing an event from PHP is only one part of delivering it promptly. A proxy, web server, compression layer, runtime, or client can hold or slow output. Check the complete path between the application and the browser.
Frame and flush events
- Return
Content-Type: text/event-streamand terminate each event with a blank line. - Ensure PHP and the runtime actually flush output. A frame emitted by the application can still be delayed by an intermediary buffer.
- Check NGINX proxy buffering and compression behavior, including whether
X-Accel-Bufferingis applicable in your configuration. Test through the reverse proxy, not only against the application process.
As Semitexa author Taras Hanych puts it, “A frame that leaves PHP immediately but sits in a proxy buffer is not a live update for your user.”
Plan for connection lifetime and load
- Account for concurrent long-lived connections, per-browser limits, and multiple tabs. MDN notes that browser connection limits can be especially restrictive with HTTP/1.x; share a connection across page features where appropriate.
- Identify idle timeouts along the route. If needed, send comment-line heartbeats, tuning their interval to the shortest relevant idle timeout rather than assuming the application server is the only timeout.
- Bound pending output for slow consumers. Decide what happens when a client cannot keep up instead of allowing unbounded queued data.
- Clean up subscriptions and other work when the client disconnects, and close the browser’s
EventSourcewhen the view or task no longer needs it.
Authorize and validate the stream
- Authorize subscriptions and the contents of each event. A stream can remain open beyond the page request that created it, so do not assume the original request alone settles every access decision.
- Native
EventSourcedoes not provide an option for arbitrary request headers. Select an authentication approach deliberately and avoid putting long-lived secrets in URLs. - Validate incoming or streamed payloads and make repeated updates safe to apply. Reconnection or replay can otherwise produce duplicate effects.
Reconnects need an application recovery plan
When a connection drops, EventSource can reconnect. An event’s id lets the browser report the last event ID on a subsequent connection, but that mechanism does not retain events or guarantee that the application can fill a gap. To recover correctly, the server needs retained events and replay logic keyed to the last ID, or the client should fetch a fresh current-state snapshot after reconnecting. Choose based on whether every transition matters or only the latest state does. If replay is used, make event handling idempotent or deduplicate by ID.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
