FIX Protocol Demystified: Building Real-Time Stock Quote Distribution

incoming.MsgSeqNum == expected → process message, increment expected
incoming.MsgSeqNum  > expected → GAP DETECTED: send ResendRequest(BeginSeqNo=expected, EndSeqNo=0)
incoming.MsgSeqNum  < expected → possible duplicate or error, check PossDupFlag

package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"
    "time"

    "github.com/quickfixgo/quickfix"
    "github.com/quickfixgo/quickfix/enum"
    "github.com/quickfixgo/quickfix/field"
    "github.com/quickfixgo/quickfix/fix44/marketdatarequest"
    "github.com/quickfixgo/quickfix/fix44/marketdatasnapshotfullrefresh"
    "github.com/quickfixgo/quickfix/fix44/marketdataincrementalrefresh"
)

type MarketDataClient struct {
    *quickfix.MessageRouter
    sessionID quickfix.SessionID
}

func NewMarketDataClient() *MarketDataClient {
    c := &MarketDataClient{
        MessageRouter: quickfix.NewMessageRouter(),
    }
    c.AddRoute(marketdatasnapshotfullrefresh.Route(c.onFullRefresh))
    c.AddRoute(marketdataincrementalrefresh.Route(c.onIncrementalRefresh))
    return c
}

func (c *MarketDataClient) OnCreate(sessionID quickfix.SessionID) {
    c.sessionID = sessionID
}

func (c *MarketDataClient) OnLogon(sessionID quickfix.SessionID) {
    fmt.Printf("[%s] Logged on to %s\n",
        time.Now().UTC().Format(time.RFC3339), sessionID)
    // Subscribe to market data after successful logon
    c.subscribe(sessionID)
}

func (c *MarketDataClient) OnLogout(sessionID quickfix.SessionID) {
    fmt.Printf("[%s] Logged out from %s\n",
        time.Now().UTC().Format(time.RFC3339), sessionID)
}

func (c *MarketDataClient) ToAdmin(msg *quickfix.Message, sessionID quickfix.SessionID) {
    // If you need to add username/password to Logon:
    // msgType, _ := msg.Header.GetString(tag.MsgType)
    // if msgType == "A" {
    //     msg.Body.SetField(tag.Username, quickfix.FIXString("myuser"))
    //     msg.Body.SetField(tag.Password, quickfix.FIXString("mypass"))
    // }
}

func (c *MarketDataClient) ToApp(msg *quickfix.Message, sessionID quickfix.SessionID) error {
    return nil
}

func (c *MarketDataClient) FromAdmin(msg *quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError {
    return nil
}

func (c *MarketDataClient) FromApp(msg *quickfix.Message, sessionID quickfix.SessionID) quickfix.MessageRejectError {
    return c.Route(msg, sessionID)
}

func (c *MarketDataClient) subscribe(sessionID quickfix.SessionID) {
    req := marketdatarequest.New(
        field.NewMDReqID(fmt.Sprintf("MDR-%d", time.Now().UnixNano())),
        field.NewSubscriptionRequestType(enum.SubscriptionRequestType_SNAPSHOT_PLUS_UPDATES),
        field.NewMarketDepth(1), // top of book
    )

    // Request bid and offer data
    entryTypes := marketdatarequest.NewNoMDEntryTypesRepeatingGroup()

    bidType := entryTypes.Add()
    bidType.SetMDEntryType(enum.MDEntryType_BID)

    askType := entryTypes.Add()
    askType.SetMDEntryType(enum.MDEntryType_OFFER)

    req.SetNoMDEntryTypes(entryTypes)

    // Subscribe to AAPL and MSFT
    symbols := marketdatarequest.NewNoRelatedSymRepeatingGroup()

    aapl := symbols.Add()
    aapl.SetSymbol("AAPL")

    msft := symbols.Add()
    msft.SetSymbol("MSFT")

    req.SetNoRelatedSym(symbols)

    if err := quickfix.SendToTarget(req, sessionID); err != nil {
        fmt.Printf("[ERROR] Failed to send subscription: %v\n", err)
    } else {
        fmt.Println("Market data subscription sent for AAPL, MSFT")
    }
}

func (c *MarketDataClient) onFullRefresh(
    msg marketdatasnapshotfullrefresh.MarketDataSnapshotFullRefresh,
    sessionID quickfix.SessionID,
) quickfix.MessageRejectError {

    symbol, _ := msg.GetSymbol()
    entries, err := msg.GetNoMDEntries()
    if err != nil {
        return err
    }

    fmt.Printf("\n=== FULL REFRESH: %s ===\n", symbol)

    for i := 0; i < entries.Len(); i++ {
        entry := entries.Get(i)
        entryType, _ := entry.GetMDEntryType()
        price, _ := entry.GetMDEntryPx()
        size, _ := entry.GetMDEntrySize()

        typeName := "UNKNOWN"
        switch entryType {
        case enum.MDEntryType_BID:
            typeName = "BID"
        case enum.MDEntryType_OFFER:
            typeName = "ASK"
        case enum.MDEntryType_TRADE:
            typeName = "TRADE"
        }

        fmt.Printf("  %s: %s @ %s\n", typeName, price.String(), size.String())
    }

    return nil
}

func (c *MarketDataClient) onIncrementalRefresh(
    msg marketdataincrementalrefresh.MarketDataIncrementalRefresh,
    sessionID quickfix.SessionID,
) quickfix.MessageRejectError {

    entries, err := msg.GetNoMDEntries()
    if err != nil {
        return err
    }

    for i := 0; i < entries.Len(); i++ {
        entry := entries.Get(i)
        action, _ := entry.GetMDUpdateAction()
        symbol, _ := entry.GetSymbol()
        entryType, _ := entry.GetMDEntryType()
        price, _ := entry.GetMDEntryPx()
        size, _ := entry.GetMDEntrySize()

        actionName := "???"
        switch action {
        case enum.MDUpdateAction_NEW:
            actionName = "NEW"
        case enum.MDUpdateAction_CHANGE:
            actionName = "CHG"
        case enum.MDUpdateAction_DELETE:
            actionName = "DEL"
        }

        fmt.Printf("[UPDATE] %s %s %s %s @ %s\n",
            actionName, symbol, entryType, price.String(), size.String())
    }

    return nil
}

func main() {
    cfgFile, err := os.Open("config/initiator.cfg")
    if err != nil {
        fmt.Printf("Failed to open config: %v\n", err)
        os.Exit(1)
    }
    defer cfgFile.Close()

    settings, err := quickfix.ParseSettings(cfgFile)
    if err != nil {
        fmt.Printf("Failed to parse settings: %v\n", err)
        os.Exit(1)
    }

    app := NewMarketDataClient()
    storeFactory := quickfix.NewFileStoreFactory(settings)
    logFactory, err := quickfix.NewFileLogFactory(settings)
    if err != nil {
        fmt.Printf("Failed to create log factory: %v\n", err)
        os.Exit(1)
    }

    initiator, err := quickfix.NewInitiator(app, storeFactory, settings, logFactory)
    if err != nil {
        fmt.Printf("Failed to create initiator: %v\n", err)
        os.Exit(1)
    }

    if err := initiator.Start(); err != nil {
        fmt.Printf("Failed to start initiator: %v\n", err)
        os.Exit(1)
    }
    defer initiator.Stop()

    fmt.Println("FIX Market Data Client started. Connecting...")

    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, os.Interrupt, syscall.SIGTERM)
    <-interrupt

    fmt.Println("Shutting down...")
}

Production Deployment: systemd, Networking, and Monitoring

This is where theory meets reality. I've seen enough FIX engines deployed in production to know that the protocol implementation is maybe 30% of the work. The other 70% is operations: process management, network configuration, monitoring, and the regulatory audit trail.

Process management with systemd

In 2017, if you're deploying Go services on Linux, you're using systemd. Period. Docker is great for packaging and CI, and I use it heavily for build reproducibility, but for long-running financial services that need reliable process management, automatic restart, and clean integration with the OS... systemd is the answer.

Here's the unit file I use:

# /etc/systemd/system/fix-marketdata.service

[Unit]
Description=FIX Market Data Distribution Engine
Documentation=https://github.com/your-org/fix-marketdata
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
User=fixengine
Group=fixengine

WorkingDirectory=/opt/fixengine
Environment="FIX_CONFIG=/etc/fixengine/acceptor.cfg"
Environment="GOMAXPROCS=4"

ExecStart=/opt/fixengine/bin/fix-marketdata
ExecReload=/bin/kill -HUP $MAINPID

Restart=on-failure
RestartSec=10
StartLimitInterval=300
StartLimitBurst=5

# Security hardening
NoNewPrivileges=true
ProtectSystem=strict
ProtectHome=true
ReadWritePaths=/opt/fixengine/store /opt/fixengine/log /var/log/fixengine

# Resource limits
LimitNOFILE=65536
LimitNPROC=4096

StandardOutput=journal
StandardError=journal
SyslogIdentifier=fix-marketdata

[Install]
WantedBy=multi-user.target

Key points:

Type=simple - Go doesn't do the double-fork dance that traditional Unix daemons use. Your binary runs in the foreground, systemd manages it directly. If you want to use Type=notify (where your application explicitly signals readiness), use the coreos/go-systemd package to call daemon.SdNotify() after acceptor.Start() succeeds.

Restart=on-failure with rate limiting - StartLimitInterval=300 and StartLimitBurst=5 means if the service crashes 5 times within 5 minutes, systemd gives up. This prevents crash loops from hammering the exchange with rapid Logon/Logout cycles, which will get your CompID banned faster than you can say "operational risk."

LimitNOFILE=65536 - each FIX session is a TCP socket. The default 1024 file descriptor limit will kill you fast when you have 200+ concurrent sessions. Set this high.

Security hardening - NoNewPrivileges, ProtectSystem=strict, ProtectHome. FIX engines don't need root access, don't need to write to system directories, and shouldn't be able to read home directories. Principle of least privilege.

Deploy and enable:

# Create service user
sudo useradd -r -s /sbin/nologin fixengine

# Deploy binary
sudo mkdir -p /opt/fixengine/{bin,store,log,spec}
sudo cp bin/fix-marketdata /opt/fixengine/bin/
sudo cp spec/FIX44.xml /opt/fixengine/spec/
sudo cp config/acceptor.cfg /etc/fixengine/acceptor.cfg

# Set permissions
sudo chown -R fixengine:fixengine /opt/fixengine
sudo chmod 750 /opt/fixengine/bin/fix-marketdata

# Install and start
sudo cp fix-marketdata.service /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl enable fix-marketdata
sudo systemctl start fix-marketdata

# Verify
sudo systemctl status fix-marketdata
sudo journalctl -u fix-marketdata -f

Network architecture

FIX runs over TCP with no standardized port - exchanges assign specific port numbers per session. Your firewall configuration needs to be precise.

IP whitelisting is STANDARD PRACTICE. Exchanges will reject connections from unknown IPs. Clients should only be able to connect from known IPs.

For connectivity to exchanges, three tiers:

Colocation - your servers physically in the exchange data center (Equinix NY4/NY5 for US equities, LD4 for London, TY3 for Tokyo). Cross-connects provide sub-millisecond round trips. This is what HFT firms use.

Leased lines - MPLS circuits from your data center to the exchange. Deterministic latency, typically single-digit milliseconds for domestic routes.

VPN tunnels - IPsec over the internet. Adequate for non-latency-sensitive connections. I use this for broker connectivity where sub-millisecond doesn't matter.

TLS for FIX (FIXS)

The FIX Trading Community published the FIXS (FIX-over-TLS) standard specifying TLS 1.2 with mutual certificate authentication. In practice, many firms rely on network-level security (dedicated lines, VPN) instead, since TLS adds measurable latency to every message. But if you're transmitting over the public internet, FIXS is the right approach.

QuickFIX/Go supports TLS via the config:

[SESSION]
SocketUseSSL=Y
SocketCertificateFile=/etc/fixengine/tls/cert.pem
SocketKeyFile=/etc/fixengine/tls/key.pem

Message store options

FIX's sequence number mechanism requires persistent state. If your engine restarts and forgets its sequence numbers, the counterparty will reject your Logon because the sequences don't match, and you're dead in the water until someone manually intervenes.

QuickFIX/Go provides:

For production, I use FileStoreFactory on SSD-backed storage. The files are small (just sequence numbers and a message index), reads are rare (only during gap-fill recovery), and writes are sequential. An SSD handles this without breaking a sweat.

For high-availability deployments where you need failover between hosts, you need shared state - either an NFS mount (simple but introduces a SPOF) or a database-backed custom store (PostgreSQL works well, and I'm already running it for everything else in my stack).

Monitoring: Prometheus + Grafana

I've run Nagios. I've run Zabbix. They work. But now, if you're starting fresh, Prometheus + Grafana is the stack. Pull-based collection, dimensional labels, PromQL for alerting, and Go has excellent client library support via prometheus/client_golang.

Key metrics to expose:

import (
    "github.com/prometheus/client_golang/prometheus"
    "github.com/prometheus/client_golang/prometheus/promhttp"
    "net/http"
)

var (
    messagesReceived = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "fix_messages_received_total",
            Help: "Total FIX messages received",
        },
        []string{"session", "msg_type"},
    )

    messagesSent = prometheus.NewCounterVec(
        prometheus.CounterOpts{
            Name: "fix_messages_sent_total",
            Help: "Total FIX messages sent",
        },
        []string{"session", "msg_type"},
    )

    messageLatency = prometheus.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "fix_message_processing_seconds",
            Help:    "Time to process incoming FIX messages",
            Buckets: []float64{.0001, .0005, .001, .005, .01, .05, .1},
        },
        []string{"session", "msg_type"},
    )

    activeSessions = prometheus.NewGauge(
        prometheus.GaugeOpts{
            Name: "fix_active_sessions",
            Help: "Number of currently connected FIX sessions",
        },
    )

    activeSubscriptions = prometheus.NewGauge(
        prometheus.GaugeOpts{
            Name: "fix_active_subscriptions",
            Help: "Number of active market data subscriptions",
        },
    )
)

func init() {
    prometheus.MustRegister(messagesReceived, messagesSent,
        messageLatency, activeSessions, activeSubscriptions)
}

// Start metrics server on a separate port (NOT the FIX port)
func startMetricsServer() {
    http.Handle("/metrics", promhttp.Handler())
    go http.ListenAndServe(":9090", nil)
}

Then in your Grafana dashboard, you get real-time visibility into message throughput, latency percentiles, session health, and subscription counts. Set alerts for session disconnects, latency spikes, and abnormal message rates.

For log aggregation, ship FIX message logs to the ELK stack (Elasticsearch + Logstash + Kibana). Every FIX message log is a regulatory audit record - MiFID II requires you to keep them, and you need to be able to search them when the regulator asks "show me every order for Client X on October 15th."

# Logstash config for FIX message logs (simplified)
input {
  file {
    path => "/opt/fixengine/log/*.log"
    type => "fix"
  }
}

filter {
  grok {
    match => { "message" => "%{TIMESTAMP_ISO8601:timestamp}.*35=%{DATA:msg_type}\x01.*49=%{DATA:sender}\x01.*56=%{DATA:target}\x01" }
  }
}

output {
  elasticsearch {
    hosts => ["localhost:9200"]
    index => "fix-messages-%{+YYYY.MM.dd}"
  }
}

MiFID II: The Regulatory Freight Train

If you're building FIX infrastructure for European markets in late 2017, MiFID II is the 800-pound gorilla in the room. Enforcement starts January 3, 2018 - about ten weeks from when I'm writing this - and it's driving the single largest wave of FIX infrastructure upgrades in the protocol's history.

The FIX Trading Community published extension packs in February 2017 covering the key requirements:

Timestamp granularity - regulated markets must provide microsecond-precision timestamps. This means exchanges like ICE are adding microsecond precision to FIX SendingTime and TransactTime fields. If your parser chokes on 52=20171015-09:30:01.123456, you have a problem.

Algorithm and trader identification - every order must carry an AlgoID identifying the algorithm that generated it, or a trader ID if manually entered. New FIX tags are being added for this.

LEI (Legal Entity Identifier) - orders must identify the legal entity placing them via the 20-character LEI code.

Short-sell marking - orders must be flagged as short sells where applicable.

Transaction reporting - expanded post-trade reporting requirements with new fields for venue of execution, waiver indicators, and client identification.

The good news: as Hanno Klein of Deutsche Börse observed, most of these requirements map to existing FIX semantics. The protocol didn't need new message types - just new fields and extension packs on existing messages. The bad news: every firm in Europe needs to upgrade their FIX engines, test against exchange certification environments, and go live before January 3rd. The compliance teams are panicking, the engineering teams are firefighting, and the exchange connectivity teams are drowning in certification requests.

If you're building new FIX infrastructure right now, target FIX 4.4 with MiFID II extension pack fields in your data dictionary. This gives you the widest compatibility with existing counterparties while supporting the new regulatory fields.

Closing Thoughts

FIX protocol is one of those technologies that rewards deep understanding. On the surface it looks simple - just key-value pairs over TCP. But the session management semantics, the market data subscription model, the repeating group parsing rules, the sequence number recovery mechanisms - there's genuine complexity hiding under the ASCII surface, and getting it wrong means missed trades, corrupted order books, or regulatory violations.

Go is the right language for this in 2017. Not because it's trendy (though the Go community would disagree with "trendy" - they'd say "pragmatic"), but because the concurrency model maps perfectly to FIX engine requirements: each session is a goroutine, channel-based communication between the engine and your business logic, and a statically compiled binary that deploys as a single file with zero runtime dependencies. No JVM tuning. No .NET framework versioning hell. Copy the binary, write the systemd unit file, start the service.

QuickFIX/Go's code generation pipeline is the hidden gem. The jump from raw tag=value manipulation to typed Go structs with compile-time safety is enormous - it eliminates an entire category of runtime bugs that have plagued FIX implementations for decades. The generated code is verbose (3,000+ lines for a single message type), but verbosity is a worthwhile trade for correctness when you're handling financial messages.

For production deployment: keep it simple. A Linux VM, systemd, file-based message store on SSD, Prometheus for metrics, ELK for audit logs, and proper firewall rules. The fancy orchestration can come later when you've proven the engine works and you need horizontal scaling. For most FIX workloads, a single well-tuned server handles hundreds of sessions without breaking a sweat.

The immediate priority for anyone in European markets: get your MiFID II data dictionary extensions in place, test against exchange certification environments, and ship before January 3rd. The clock is ticking.

If you have questions, want to see more detailed examples, or need help with a specific exchange's FIX implementation, drop me a line. I'm always happy to talk protocol internals with people who appreciate the beauty of a well-sequenced session.