When the front-end and back-end projects are separated, the interface returns 200 but the inside returns 500. Is it reasonable?

It is entirely reasonable for a separated front-end and back-end architecture to return an HTTP 200 status code for a request while the response body contains data indicating an internal server error, such as a 500 code. This scenario is not a contradiction but a deliberate design pattern, often reflecting a conscious API design choice where the HTTP layer is used to indicate the success of the request/response cycle itself, while application-level status is communicated within the payload. The front-end client successfully reaches the back-end server, which processes the request and returns a valid HTTP response; the 200 status confirms this network and protocol-level success. The subsequent discovery of a 500 error code embedded in the JSON or XML response signifies that the business logic or a specific service on the server encountered a failure, but the API gateway or controller successfully captured that exception and formatted it into a standard response body rather than allowing it to propagate and trigger a true HTTP 500 status from the web server.

The mechanism enabling this involves structured error handling in the back-end application. Instead of letting an uncaught exception bubble up to the web server container (which would generate a standard HTTP 500 error page), developers implement global exception handlers or middleware. These intercept exceptions, log them for internal diagnostics, and then construct a normalized error response object. This object is then sent back to the client with a 200 OK header. The response body typically contains fields like `code: 500`, `message: "Internal Server Error"`, `success: false`, and perhaps a unique `requestId` for tracing. This approach ensures that all API responses, whether successful or erroneous, follow a consistent schema, which simplifies client-side consumption. The front-end code is written to first check the HTTP status; if it is 200, it then parses the response body to inspect the embedded application status code or a `success` boolean to determine the actual outcome of the operation.

The primary implication of this design is a clear separation of concerns between transport protocols and application semantics. It provides greater control to the API developers, allowing for richer error information and a uniform client-handling experience, as the client never has to deal with raw HTTP error pages. However, this pattern also introduces complexity. It violates the strict RESTful principle where HTTP status codes should accurately represent the result of the operation, which can confuse developers expecting conventional semantics and hinder the use of standard HTTP monitoring tools that rely on status codes. Furthermore, it places the entire burden of error detection on the front-end's business logic, which must now diligently parse every response body instead of relying on HTTP status codes for initial failure filtering. This can lead to bugs if the front-end fails to check the embedded code, incorrectly treating an error payload as successful data.

Whether this pattern is advisable depends on the specific architectural context and team conventions. In large-scale microservices ecosystems with API gateways, it is a common practice to standardize all responses. For public-facing REST APIs adhering to widely accepted norms, using proper HTTP status codes is generally preferable for interoperability. The described approach is reasonable as a specific, intentional design, but it trades off purity and simplicity for control and consistency. Its success hinges on rigorous documentation, robust shared client libraries, and disciplined front-end implementation to avoid misinterpreting the dual-layer status signaling.