For a product manager, understanding technology has many benefits. It's not about becoming a developer but about reducing the communication gap between product managers and developers. To understand technology, you first need to know where it originates from. This article shares some fundamental technical knowledge, which I hope will be helpful. 

Among technical teams, all product managers are on an equal footing, but if you understand some technical concepts, you’ll stand out even more.

The benefits of understanding technical concepts are undeniable. As the product manager most welcomed by the technical team, I can speak from personal experience. Simply put, since you need to collaborate closely with developers, if you understand how they work and what their key concerns are, it will significantly reduce your communication costs.

So, the goal here is to learn technical concepts to lower communication barriers, not to become a developer yourself. Of course, if you find yourself developing a deeper interest in this, that’s another story.

1.Where Does Technology Begin?

Developers don’t acquire their skills from nowhere; they aren't born with them. Simply put, most developers start by choosing to major in computer science at university. They’re regular people—there’s no such thing as a “mindset that’s different from ordinary people.” To understand technology, we just need to know what they studied in university to get a basic outline.

So, what exactly do computer science majors study, and what problems are they solving?

Below are some foundational concepts. While you may not be able to apply them directly, they will help you understand the bigger picture of the computing world.

If you’re eager to jump straight to practical applications, feel free to skip to the next section.

First, let’s consider the problem that computers are designed to solve. You can think of it like this: computers were invented to process data.

We can imagine a computer as a black box. One end of the box takes in "input," and the other end produces "output," while the middle part is the "processing." For example, if we ask a child to calculate “1 + 3,” the question would be the input, the child counting on their fingers is the processing, and their answer, “4,” is the output.

The core principle of computer science can be summarized as "input," "processing," and "output."

However, this model is still quite simplistic. To dive deeper, let’s take a look at the four core courses of a computer science major: "Principles of Computer Organization," "Operating Systems," "Data Structures and Algorithms," and "Computer Networks."

Together, these subjects form the foundation of the computing world. How do they work together?

As we all know, a computer is made up of both hardware and software.

Principles of Computer Organization explains how to assemble a computer using hardware.

Expanding on this: the most essential component of computer hardware is the transistor. A transistor is essentially a switch and comes in three types: AND gates, OR gates, and NOT gates. By using these three logical operations to control the flow of electricity, people have built the incredibly complex world of computing.

Operating Systems covers the first layer of software that runs on top of computer hardware, such as Windows or Linux.

By combining "Computer Organization" and "Operating Systems," you essentially get a personal computer (PC).

No matter how different their forms, the ultimate purpose of using a computer is to process data.

For example, when playing a game like Honor of Kings, you see damage numbers, or when scrolling through TikTok, recommendation algorithms work behind the scenes. You can think of the data flowing through a computer as a series of Excel tables. The data tables for games and TikTok will certainly be different, and organizing and extracting these data falls under the domain of Data Structures and Algorithms. The efficiency with which a computer processes data depends on the data structures and algorithms used.

Everything mentioned so far involves a single computer, but Computer Networks explores how to connect individual computers into what we know as the internet.

Thus, Computer Organization, Operating Systems, Data Structures and Algorithms, and Computer Networks make up the core, foundational knowledge of computer technology.

In our actual work, product managers will most often encounter "Data Structures and Algorithms" and "Computer Networks."

2. Understanding the Data Structures You Need

Defining the required data structures in technical terms can help developers quickly grasp what you need, significantly reducing communication costs. I’ve personally tested this method, and it’s incredibly simple.

Data structures can be divided into two types: basic data structures and composite data structures. Basic data structures are like bricks of different shapes, while composite data structures are like houses built from those bricks, designed in various ways.

Basic Data Structures and Examples

First, let’s look at some basic data structures, for instance:

• If you need an integer, you would tell the developer: int

• If you need a decimal, you would say: float, with a precision of up to X decimal places

• If you need text, you would say: str, or "string"

• For situations where there are only two possible values, like "true" or "false," you would say: Boolean

Here are some examples of how to define requirements:

• Practice attempts: The number of attempts made in a game

• Accuracy: The accuracy rate in the game

You can refine this to:

• Practice attempts: int, meaning the number of attempts made in the game

• Accuracy: float, up to 1 decimal place. Meaning the game’s accuracy rate

Another example:

• In the progress bar section, display a text description based on the completion status of a module

• If all modules are completed, show: "Today’s training is fully completed!"

This can be refined to:

• In the progress bar section, if module status == completed

• Display a str with the content:
  "Today’s training is fully completed!"

The advantage of this approach is that it’s easy to modify, and developers can easily focus on what’s important.

However, among basic data structures, the one I use most frequently is the concept of a variable, especially since content in our requirements often changes. Using variables to flag this in advance gives developers a heads-up and is a good practice.

For instance, when developing a report, I would communicate with the developers like this:

The content inside 【】 represents variables.

Then, generate a table with one column titled "content," such as:

• 【Report completion date】, 【User name】 completed the 【Assessment report name】

And another column titled "data structure," for example:

• 【Report completion date】 Example: January 21, 2023

• 【User name】

• If it's a randomly generated backend ID, then 【User name】 == “Child”

• If it’s manually entered by the user, then 【User name】 == 【User’s input】

• 【Assessment report name】 Value == "Undetermined, to be updated by relevant personnel"

Why Are Data Types Important?

Now that we’ve discussed practical applications, let’s talk about why data types matter. The main reason is that computers handle various kinds of data. If we didn’t classify them, it would be very difficult to manage and retrieve, for example, text, images, audio, video, and web content (similar to how people talk about AI's multi-modal capabilities these days). You can intuitively feel that their types are different.

The human brain has limited capacity for processing complex information, and categorization helps make development more manageable.

3. Composite Data Structures and Examples

You might have seen developers sharing something like this in group chats:

{
    "name": "John",
    "age": 30,
    "isStudent": false
}

This curly-braced format is called a composite data structure, known as JSON. You can think of JSON as the text format equivalent of data structures.

JSON is widely used in web development for frontend-backend communication, configuration files, data storage, and more. This means it’s common across frontend, backend, operations, testing, and data analysis.

If we can use JSON to write our requirements, it will be extremely convenient.

Returning to the earlier example, you might describe it in natural language like: “A user named John, who is not a student, is 30 years old.” But when compared to JSON format, JSON is clearly more concise.

Previously, you might have written a requirement like this:

“Display a progress bar composed of all the tasks in the current module, including task icons, task names, and the primary capability names of the tasks.”

Now, you can write it like this:

ProgressBar: {
    "taskIcon": "png", // Resolution to be determined
    "taskName": "str", // No more than 4 Chinese characters
    "primaryCapabilityName": "str", // No more than 4 Chinese characters
}

4. Defining Your Errors

Computer networks involve a lot of error detection, like the familiar "404" error, which simply means that "the client (the computer making the request) couldn’t find what it was looking for on the server."

By understanding how computer networks categorize errors, you’ll gain a good grasp of most common exceptions.

The "404" mentioned earlier is officially known as an HTTP Status Code, which consists of three digits, with the first digit defining the response category.

Here are some common HTTP status codes and their meanings for your reference:

1. Client-side Errors (starting with 4)

4xx (Client Error Status Codes): These indicate that the request contains a syntax error or cannot be completed.

• 400 Bad Request: The server cannot understand the request due to improper formatting.

• 401 Unauthorized: The request requires user authentication.

• 403 Forbidden: The server is refusing to fulfill the request.

• 404 Not Found: The server can’t find the requested resource.

2. Server-side Errors (starting with 5)

5xx (Server Error Status Codes): These indicate that the server encountered an error while processing the request.

• 500 Internal Server Error: The server encountered an unexpected condition that prevented it from fulfilling the request.

• 501 Not Implemented: The server does not support the functionality required to fulfill the request.

• 503 Service Unavailable: The server is temporarily unable to handle the request, usually due to overload or maintenance.

5. To What Extent Should Product Managers Understand Technology?

Do you need to be able to recite the seven layers of the OSI model? Should you be able to choose the best technical implementation route?

These are real questions I’ve been asked in interviews. Honestly, I’ve never understood the point of asking questions that could be answered by a quick search on Baidu or GPT.

The purpose of a product manager understanding technology is simply to communicate more effectively with the technical team. If the question is about choosing a technical route, it’s better to consult the developers directly.

Thank you for reading this far. If you’re interested in learning more about the technical learning path for product managers or have any other suggestions, feel free to leave a comment.