Google .NET Developer Interview Questions & Answers

I would first ask a few focused questions to understand why the requirement changed, what user need it solves, and whether it is required for the current release. Then I would review the existing API contract, the .NET code that implements it, its automated tests, and the known consumers of the API. I would identify options instead of immediately changing the existing behavior. For example, if changing an existing response could break consumers, I would consider adding an optional field or a separate endpoint while keeping the current contract stable. I would explain the impact and tradeoffs in simple terms to the product owner and the engineers who depend on the API. If the safest option required reducing the scope of the new request, I would say that early and explain why. After the team agreed on an approach, I would implement the smallest reliable change, add tests for the new behavior and existing behavior, ask another engineer to review the change, and verify the important integration paths before release. If I discovered information that changed the risk, I would communicate it immediately rather than continuing with the original plan.

I first separated what we knew from what we were assuming. We knew our current request pattern, the importance of the workflow, and the behavior we had already observed from the external API. The uncertain parts were its practical capacity and how quickly it might start rejecting requests as traffic increased. I decided that the safest option was not to assume unlimited capacity. I based my decision on three criteria: protecting the existing user flow, making the change easy to reverse, and giving us enough visibility to detect problems quickly. I implemented the new behavior behind a feature flag so we could enable or disable it without another deployment. I also limited the amount of concurrent work instead of allowing every request to call the external API at once. I added structured logging and monitoring around response times, failures, and rejected requests so we could compare the new behavior with the existing baseline. I explained to the team which parts of the decision were based on evidence and which parts were assumptions. We agreed to release the change gradually and review the production signals before increasing its use. After release, I compared the observed behavior with the assumptions I had documented and checked whether the external dependency remained stable. This let us validate the decision with real production data instead of treating the original assumptions as facts.

I started by collecting data from our application logs, request timing information, and database query records for the periods when users reported slowness. I compared slow requests with normal requests and looked for patterns that appeared only during the affected periods. I found that most application operations were completing normally, but a small group of requests spent much more time waiting for one database query. I then reviewed that query and its execution behavior with the database data available to us. The evidence showed that the query was reading more data than the application actually needed. I created a small test using the same type of request and confirmed that limiting the query to the required fields and records reduced the unnecessary database work. I shared the data and my reasoning with the team before making the change, so everyone could see why I believed the database access pattern was the main cause. After we agreed on the approach, I updated the .NET data access code, tested the affected workflow, and continued watching the same logs and request timing data after deployment to make sure the behavior improved.

I first stopped arguing about which approach was better and asked my colleague to walk me through the reason for the proposed change. That helped me understand that the main concern was meeting the requested behavior without creating unnecessary work. I then explained my concern using the actual API dependency instead of only stating my opinion. I showed how changing the existing response could affect the current consumer and suggested that we preserve the existing contract while adding the new behavior in a compatible way. We reviewed the affected code together and discussed the tradeoffs of both approaches. I made it clear that I was not trying to block the change. My goal was to reduce the chance of creating another problem during the release. We agreed on an approach that met the requested behavior and kept the existing integration stable. I also kept the conversation focused on the technical problem and acknowledged the valid points in my colleague's original suggestion.