PATCH for partial updates in Rest API - Step-by-Step Execution

Concept Flow - PATCH for partial updates

Client sends PATCH request

↓

Server receives PATCH request

↓

Server reads partial data to update

↓

Server updates only specified fields

↓

Server saves changes

↓

Server sends response with updated resource

↓

End

The client sends a PATCH request with only the fields to update. The server updates those fields without changing others, then responds with the updated resource.

Execution Sample

Rest API

PATCH /users/123 HTTP/1.1
Content-Type: application/json

{"email": "[e-mail]"}

Client sends a PATCH request to update only the email field of user 123.

Execution Table

Step	Action	Data Received	Fields Updated	Server Response
1	Receive PATCH request	{"email": "[e-mail]"}	None yet	None yet
2	Parse JSON body	{"email": "[e-mail]"}	None yet	None yet
3	Find user 123 in database	User data before update	None yet	None yet
4	Update email field only	Email field value	email	None yet
5	Save updated user data	User data with new email	email	None yet
6	Send response with updated user	User data with new email	email	200 OK with updated user JSON
7	End	None	None	Response sent

💡 PATCH request processed; only specified fields updated; server responded with updated resource.

Variable Tracker

Variable	Start	After Step 4	After Step 5	Final
user_data	{"name": "Alice", "email": "[e-mail]", "age": 30}	{"name": "Alice", "email": "[e-mail]", "age": 30}	{"name": "Alice", "email": "[e-mail]", "age": 30}	{"name": "Alice", "email": "[e-mail]", "age": 30}

Key Moments - 3 Insights

Why does PATCH update only some fields and not replace the whole resource?

Because PATCH is designed for partial updates, the server updates only the fields sent in the request (see execution_table step 4), leaving other fields unchanged.

What happens if the PATCH request body is empty?

The server receives no fields to update (execution_table step 2), so no changes are made and the original resource is returned.

How does the server know which user to update?

The user ID is specified in the URL (e.g., /users/123), so the server finds the correct user before updating (execution_table step 3).

Visual Quiz - 3 Questions

Look at the execution table, at which step does the server update the email field?

A Step 4

B Step 2

C Step 5

D Step 6

💡 Hint

Check the 'Fields Updated' column in the execution_table rows.

According to the variable tracker, what is the user's email after step 5?

A "[e-mail]"

B null

C "[e-mail]"

D Not updated yet

💡 Hint

Look at the 'user_data' row under 'After Step 5' in variable_tracker.

If the PATCH request included the 'age' field, how would the execution table change?

A No change, only email is updated

B Fields Updated would include 'email' and 'age' at step 4

C Server would reject the request

D Response would be empty

💡 Hint

Refer to how 'Fields Updated' is shown in execution_table step 4.

Concept Snapshot

PATCH request updates only specified fields of a resource.
Client sends partial data in request body.
Server merges changes without replacing whole resource.
Response returns updated resource.
Used for efficient partial updates in REST APIs.

Full Transcript

PATCH is a method in REST APIs used to update only parts of a resource. The client sends a PATCH request with just the fields to change. The server finds the resource, updates only those fields, saves the changes, and sends back the updated resource. This avoids sending or replacing the entire resource. For example, updating only a user's email without changing their name or age. The execution table shows each step from receiving the request to sending the response. The variable tracker shows how the user data changes only in the email field. Common confusions include why PATCH updates partially, what happens if no fields are sent, and how the server identifies which resource to update. The visual quiz tests understanding of these steps and changes.

Practice

1. What is the main purpose of using the PATCH method in REST APIs?

easy

A. To update only specific fields of a resource without sending the entire data

B. To create a new resource on the server

C. To delete a resource completely

D. To retrieve data from the server

Solution

1. Step 1: Understand HTTP methods

   HTTP methods like GET, POST, PUT, DELETE, and PATCH have different purposes. PATCH is designed for partial updates.

2. Step 2: Identify PATCH behavior

   PATCH sends only the fields that need to be changed, unlike PUT which requires the full resource data.

3. Final Answer:

   To update only specific fields of a resource without sending the entire data -> Option A

4. Quick Check:

   PATCH updates parts only [OK]

Hint: PATCH updates parts, not whole resource [OK]

Common Mistakes:

• Confusing PATCH with PUT which replaces full resource
• Thinking PATCH creates new resources
• Using PATCH to delete resources

2. Which of the following is the correct way to send a PATCH request to update a user's email using JSON?

easy

A. PATCH /users/123 {"email": "[e-mail]"}

B. PATCH /users/123 {"username": "newuser"}

C. GET /users/123 {"email": "[e-mail]"}

D. DELETE /users/123 {"email": "[e-mail]"}

Solution

1. Step 1: Identify HTTP method and endpoint

   PATCH is used to update part of the resource at /users/123.

2. Step 2: Check JSON body for correct field

   The JSON body contains only the field to update, here "email" with new value.

3. Final Answer:

   PATCH /users/123 {"email": "[e-mail]"} -> Option A

4. Quick Check:

   PATCH + partial JSON body = correct syntax [OK]

Hint: PATCH with only fields to update in JSON body [OK]

Common Mistakes:

• Using GET or DELETE instead of PATCH
• Sending unrelated fields in PATCH body
• Trying to update username when email is asked

3. Given this PATCH request body to update a product:

{"price": 19.99}

What will be the result if the original product data was

{"name": "Book", "price": 25.00, "stock": 10}

?

medium

A. {"name": "Book", "price": 25.00, "stock": 10}

B. {"price": 19.99}

C. {"name": "Book", "price": 19.99, "stock": 10}

D. {"name": "Book", "stock": 10}

Solution

1. Step 1: Understand PATCH partial update

   PATCH updates only the fields sent, here "price" changes to 19.99.

2. Step 2: Combine unchanged fields with updated field

   Fields not in PATCH body remain unchanged, so "name" and "stock" stay the same.

3. Final Answer:

   {"name": "Book", "price": 19.99, "stock": 10} -> Option C

4. Quick Check:

   PATCH updates price only, others unchanged [OK]

Hint: PATCH changes only sent fields, keeps others [OK]

Common Mistakes:

• Replacing entire object instead of partial update
• Removing fields not in PATCH body
• Ignoring updated field in result

4. You send this PATCH request to update a user's profile:

{"email": "[e-mail]", "age": "twenty"}

The server expects age as an integer. What is the likely problem?

medium

A. The PATCH request will succeed and update both fields

B. The server will delete the age field from the user profile

C. The server will ignore the age field and update only email

D. The server will reject the request due to invalid data type for age

Solution

1. Step 1: Check data types in PATCH body

   "age" is sent as string "twenty" but server expects integer.

2. Step 2: Understand server validation

   Most servers validate data types and reject requests with invalid types.

3. Final Answer:

   The server will reject the request due to invalid data type for age -> Option D

4. Quick Check:

   Invalid data type causes rejection [OK]

Hint: Check data types match server expectations [OK]

Common Mistakes:

• Assuming server auto-converts wrong types
• Thinking PATCH ignores invalid fields silently
• Believing PATCH deletes fields on error

5. You have a REST API for managing tasks with fields: title, completed, and priority. You want to mark a task as completed without changing other fields. Which PATCH request body is best?

hard

A. {"title": "", "completed": true, "priority": null}

B. {"completed": true}

C. {"completed": true, "priority": "high"}

D. {"title": "New Task"}

Solution

1. Step 1: Identify minimal update needed

   Only the "completed" field needs to change, so send only that.

2. Step 2: Avoid sending unrelated or empty fields

   Sending empty or null fields may overwrite data unintentionally.

3. Final Answer:

   {"completed": true} -> Option B

4. Quick Check:

   Send only changed fields in PATCH body [OK]

Hint: Send only fields you want to update in PATCH [OK]

Common Mistakes:

• Sending all fields even if unchanged
• Sending empty or null values accidentally
• Using PUT instead of PATCH for partial update