Serialization vs Deserialization in JavaScript

When I first came across the term Serialization in a backend lecture, it immediately sounded like something complex and heavy to me.

The instructor mentioned that when we send data using res.json(), we are actually sending a serialized object. At that moment, I didn’t question it much, but in my head, I assumed it must be one of those deep technical concepts.

Curious, I decided to look it up. I opened the MDN documentation, expecting a long and detailed explanation.

But surprisingly, it was just a couple of lines. And the funny part?

That short explanation was enough for me to understand the concept completely. Not just serialization, but also its counterpart deserialization.

That’s when I realized: sometimes, the terms sound heavier than the actual concept.

So if you’re also wondering what serialization and deserialization really mean, let’s uncover it step by step.

---

What is Serialization?

In simple terms, serialization is the process of converting complex data into a format that can be sent over a network or stored.

When we work in programming, we often deal with complex data structures like objects or arrays. But the network doesn’t understand these structures directly. It only understands data in the form of bytes (or strings, in many cases).

So, before sending data over the internet, we convert these complex structures into a simpler format.

This conversion process is called serialization.

For example, in JavaScript, we use JSON.stringify() to convert an object into a string:

JSON.stringify({ name: "Chirag" });

Output:

'{"name": "Chirag"}'

Now this string can be easily sent over the network or stored, and later reconstructed back into its original form.

---

What is Deserialization?

If serialization is about converting data into a transferable format, deserialization is simply the reverse process.

It means converting the serialized data back into its original form so that we can use it in our application.

For example, in JavaScript, we use JSON.parse() to convert a string back into an object:

JSON.parse('{"name":"Chirag"}');

Output:

{ name: "Chirag" }

Now the data is back in a usable format, and we can access its properties just like a normal object.

---

Before moving ahead, let’s pause for a moment and think about this.

Now that we understand serialization and deserialization, what happens if we forget to perform these operations?

What kind of problems can it cause in a real application?

Let’s explore that.

---

What happens if we skip serialization or deserialization?

Let’s understand this with a real example localStorage.

In the browser, localStorage is used to store data in the form of key-value pairs. But there’s a limitation: it only stores data as strings.

Now suppose we try to store an object directly in it:

localStorage.setItem("user", { name: "Chirag" });

At first glance, this might look fine. But internally, the object gets converted into a string like this:

"[object Object]"

This means our original data structure is lost.

To avoid this, we use serialization:

localStorage.setItem("user", JSON.stringify({ name: "Chirag" }));

Now the data is stored properly.

---

But what if we forget deserialization?

When we retrieve the data:

const user = localStorage.getItem("user");

The value of user is still a string, not an object.

If we try to use it like an object:

console.log(user.name);

We get:

undefined

This doesn’t throw an error but it silently gives incorrect results.

---

Why is this dangerous?

Because in JavaScript, many such mistakes don’t immediately crash your application. Instead, they lead to silent failures, where your logic breaks without obvious errors.

This can result in:

• Incorrect UI behavior

• Failed conditions

• Bugs that are hard to trace in large codebases

And that’s why properly handling serialization and deserialization is not just a formality it’s essential.

---

Conclusion

By now, you should have a clear understanding of what serialization and deserialization really mean. Concepts like these might sound complex at first, but once you break them down, they turn out to be surprisingly simple.

More importantly, understanding them helps you avoid subtle bugs especially in JavaScript, where mistakes can silently break your logic without obvious errors.

And that’s the key takeaway:

sometimes, it’s not the complexity of a concept that makes it difficult it’s just the name.