Serialization in Go: Choosing the Right Format for the Right Job

What Is Serialization?

Serialization is the process of converting complex in-memory data structures — such as structs, maps, or slices — into a format that can be:

• Stored (e.g., in files or databases)
• Transmitted (e.g., over a network between services)

This serialized format could be JSON, XML, YAML, Protobuf, Avro, or others — depending on the use case.

Once data is received or retrieved, deserialization performs the reverse: it reconstructs the original data structure from the serialized format so that your application can work with it as native objects again.

Think of it like packaging and unpackaging your data — safely, efficiently, and consistently.

Why Does Serialization Matter So Much?

In real-world systems, serialization is the glue that connects services, stores state, and moves data across the wire.

Here’s how it powers modern applications:

• APIs (REST/gRPC): Translates in-memory data into formats like JSON, Protobuf, or XML to communicate between client and server.
• Persistent Storage: Saves object states to files or databases for future use and recovery.
• Message Queues: Transfers serialized data through systems like Kafka, RabbitMQ, or NATS for event-driven communication.
• Config Management: Reads structured configuration from YAML, JSON, or TOML files during app initialization.
• Microservices Communication: Enables services to exchange structured data efficiently and reliably.

👉 Choosing the wrong serialization format can lead to:

• Slower API response times
• Increased payload sizes
• Fragile integrations between systems
• Higher maintenance complexity over time

That’s why it’s crucial to understand when and why to use each format. In this article, we’ll dive deep into some of the most commonly used serialization formats in Go

JSON

JSON (JavaScript Object Notation) is a lightweight, text-based, language-independent data format. It is the most common serialization format used in REST APIs, web applications, and data interchange.

Below is an example of struct definition and serializing it in Golang using JSON:

type Order struct {
	OrderID   string   `json:"order_id"`
	Customer  string   `json:"customer"`
	Items     []string `json:"items"`
	Total     float64  `json:"total"`
	Delivered bool     `json:"delivered"`
}

order := Order{
	OrderID:   "ORD1001",
	Customer:  "Aslam",
	Items:     []string{"Phone", "Laptop"},
	Total:     299.99,
	Delivered: false,
}

jsonData, _ := json.MarshalIndent(order, "", "  ")
fmt.Println(string(jsonData))        

Use When:

• You’re building REST APIs
• You need browser or mobile clients
• You want easy debugging and logging
• You’re exposing public APIs

Avoid When:

• You need compact or high-performance data exchange
• You require schema evolution or strict typing

YAML

YAML (YAML Ain’t Markup Language) is a user-friendly, indentation-based format commonly used for configuration files like docker-compose.yaml, kubernetes.yaml, and CI/CD tools.

Below is an example of struct definition and serializing it in Golang using YAML:

type Config struct {
	Host  string `yaml:"host"`
	Port  int    `yaml:"port"`
	Debug bool   `yaml:"debug"`
}

config := Config{"localhost", 8080, true}
yamlData, _ := yaml.Marshal(config)
fmt.Println(string(yamlData))        

Use When:

• You need configuration files (e.g., Docker Compose, Kubernetes, CI/CD)
• You're working with DevOps tools
• Readability for humans is a priority

Avoid When:

• You’re transferring data between services
• The system is performance-critical
• You want to avoid indentation-sensitive formats

XML

XML (eXtensible Markup Language) is a structured, verbose format traditionally used in enterprise, banking, and government software.

Below is an example of struct definition and serializing it in Golang using XML:

type Invoice struct {
	XMLName xml.Name `xml:"invoice"`
	ID      string   `xml:"id"`
	Amount  float64  `xml:"amount"`
}

invoice := Invoice{"", "INV-123", 499.99}
xmlData, _ := xml.MarshalIndent(invoice, "", "  ")
fmt.Println(string(xmlData))        

Use When:

• You’re integrating with legacy enterprise systems
• You’re working with government/BFSI or SOAP APIs
• You need schema validation (XSD) or namespaces

Avoid When:

• Performance and payload size are critical
• You're targeting mobile or low-bandwidth environments
• You have the option to use JSON or Protobuf

Protobuf

Protocol Buffers (Protobuf) is a binary serialization format developed by Google. It’s schema-based, highly compact, and extremely fast.

Below is an example of struct definition using .proto file and serializing it in Golang using Protobuf:

// invoice.proto
syntax = "proto3";

message Invoice {
  string id = 1;
  float amount = 2;
}        

//main.go
invoice := &pb.Invoice{Id: "INV-123", Amount: 499.99}
protoData, _ := proto.Marshal(invoice)
fmt.Printf("Serialized data: %x\n", protoData)        

Use When:

• You’re building high-performance microservices
• You're using gRPC as your communication protocol
• You want compact, fast, binary serialization
• You need schema evolution and contract enforcement

Avoid When:

• You're building quick PoCs or CLI scripts
• You require human-readable formats
• You don’t want to manage .proto file generation or tooling

Conclusion

Serialization isn't just a technical detail — it's a core design decision that affects performance, maintainability, interoperability, and scalability of your system.

There’s no “one-size-fits-all” solution. Each format has its sweet spot:

• JSON is your go-to for web APIs, browser/mobile clients, and debugging ease.
• YAML shines in configuration files and DevOps workflows, but not in production APIs.
• XML still holds ground in legacy systems, especially where formal schemas are essential.
• Protobuf is the champion of speed, efficiency, and schema evolution, perfect for microservices and gRPC.

The key takeaway? Choose the format that fits your use case—not just the one you’re most familiar with.