PATCH for partial updates in Rest API - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the response status code after a successful PATCH request?

Consider a REST API where you send a PATCH request to update a user's email partially. The server successfully updates the email field.

What is the typical HTTP status code returned by the server?

A 200 OK

B 201 Created

C 204 No Content

D 400 Bad Request

💡 Hint

PATCH updates part of a resource and usually returns the updated resource.

A successful PATCH request typically returns 200 OK with the updated resource in the response body. 201 Created is for new resources, 204 No Content means no body returned, and 400 Bad Request means the request was invalid.

🧠 Conceptual

intermediate

Why use PATCH instead of PUT for partial updates?

Which reason best explains why PATCH is preferred over PUT when updating only some fields of a resource?

A PATCH always returns 201 Created, PUT does not.

B PATCH requires sending the full resource, PUT only partial data.

C PATCH updates only specified fields without affecting others, while PUT replaces the entire resource.

D PATCH is faster because it uses GET method internally.

💡 Hint

Think about what happens to fields not included in the request.

PATCH modifies only the fields sent in the request, leaving other fields unchanged. PUT replaces the entire resource, so missing fields are removed or reset.

🔧 Debug

advanced

Identify the error in this PATCH request handler code

Given this Python Flask code snippet handling a PATCH request, what error will occur?

from flask import Flask, request, jsonify
app = Flask(__name__)

users = {1: {'name': 'Alice', 'email': '[e-mail]'}}

@app.route('/users/<int:user_id>', methods=['PATCH'])
def update_user(user_id):
    data = request.json
    if user_id not in users:
        return jsonify({'error': 'User not found'}), 404
    users[user_id].update(data)
    return jsonify(users[user_id]), 200

if __name__ == '__main__':
    app.run()

A TypeError if request.json is None because no JSON was sent

B KeyError if user_id is not in users

C SyntaxError due to incorrect route decorator

D No error, code runs correctly

💡 Hint

What happens if the client sends an empty or invalid JSON body?

If request.json is None (no JSON sent), calling update() on None causes a TypeError. The code does not check if data is valid before updating.

📝 Syntax

advanced

Which PATCH request JSON body is valid for partial update?

You want to update only the email field of a user via PATCH. Which JSON body is syntactically correct and valid for this partial update?

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

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

C {"email" => "[e-mail]"}

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

💡 Hint

Remember JSON syntax rules for strings and commas.

Option B is valid JSON with a key-value pair. Option B has a trailing comma which is invalid in JSON. Option B uses => instead of colon. Option B misses quotes around the string value.

🚀 Application

expert

What is the final user data after this PATCH sequence?

Given the initial user data:

{"name": "Bob", "email": "[e-mail]", "age": 30}

And these two PATCH requests applied in order:

PATCH 1 body: {"email": "[e-mail]"}
PATCH 2 body: {"age": null}

What is the final user data after both PATCH requests?

A {"name": "Bob", "email": "[e-mail]", "age": 30}

B {"name": "Bob", "email": "[e-mail]", "age": 0}

C {"name": "Bob", "email": "[e-mail]"}

D {"name": "Bob", "email": "[e-mail]", "age": null}

💡 Hint

PATCH replaces or sets fields sent, including null values.

The first PATCH updates the email field. The second PATCH sets the age field to null explicitly. PATCH does not remove fields unless the value is set to null or the server treats null as removal.

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