func (p *connPool) roundTrip(ctx context.Context, req Request) (Response, error) {
 	// This first select should never block after the first metadata response
 	// that would mark the pool as `ready`.
 	select {
 	case <-p.ready:
 	case <-ctx.Done():
 		return nil, ctx.Err()
 	}
 
 	var expectTopics []string
-	defer func() {
-		if len(expectTopics) != 0 {
-			p.refreshMetadata(ctx, expectTopics)
-		}
-	}()
 
 	state := p.grabState()
 	var response promise
 
 	switch m := req.(type) {
 	case *meta.Request:
 		// We serve metadata requests directly from the transport cache.
 		//
 		// This reduces the number of round trips to kafka brokers while keeping
 		// the logic simple when applying partitioning strategies.
 		if state.err != nil {
 			return nil, state.err
 		}
 		return filterMetadataResponse(m, state.metadata), nil
 
 	case *createtopics.Request:
 		// Force an update of the metadata when adding topics,
 		// otherwise the cached state would get out of sync.
 		expectTopics = make([]string, len(m.Topics))
 		for i := range m.Topics {
 			expectTopics[i] = m.Topics[i].Name
 		}
 
 	case protocol.Splitter:
 		// Messages that implement the Splitter interface trigger the creation of
 		// multiple requests that are all merged back into a single results by
 		// a merger.
 		messages, merger, err := m.Split(state.layout)
 		if err != nil {
 			return nil, err
 		}
 		promises := make([]promise, len(messages))
 		for i, m := range messages {
 			promises[i] = p.sendRequest(ctx, m, state)
 		}
 		response = join(promises, messages, merger)
 	}
 
 	if response == nil {
 		response = p.sendRequest(ctx, req, state)
 	}
 
+	r, err := response.await(ctx)
+	if err != nil {
+		return r, err
+	}
+	
+	if len(expectTopics) != 0 {
+		p.refreshMetadata(ctx, expectTopics)
+	}
+	
+	return r, nil
-	return response.await(ctx)
 }

-func (p *connPool) roundTrip(ctx context.Context, req Request) (Response, error) {
+func (p *connPool) roundTrip(ctx context.Context, req Request) (r Response, err error) {
 	// This first select should never block after the first metadata response
 	// that would mark the pool as `ready`.
 	select {
 	case <-p.ready:
 	case <-ctx.Done():
 		return nil, ctx.Err()
 	}
 
 	var expectTopics []string
 	defer func() {
-		if len(expectTopics) != 0 {
+		if err == nil && len(expectTopics) != 0 {
 			p.refreshMetadata(ctx, expectTopics)
 		}
 	}()
 
 	state := p.grabState()
 	var response promise
 
 	switch m := req.(type) {
 	case *meta.Request:
 		// We serve metadata requests directly from the transport cache.
 		//
 		// This reduces the number of round trips to kafka brokers while keeping
 		// the logic simple when applying partitioning strategies.
 		if state.err != nil {
 			return nil, state.err
 		}
 		return filterMetadataResponse(m, state.metadata), nil
 
 	case *createtopics.Request:
 		// Force an update of the metadata when adding topics,
 		// otherwise the cached state would get out of sync.
 		expectTopics = make([]string, len(m.Topics))
 		for i := range m.Topics {
 			expectTopics[i] = m.Topics[i].Name
 		}
 
 	case protocol.Splitter:
 		// Messages that implement the Splitter interface trigger the creation of
 		// multiple requests that are all merged back into a single results by
 		// a merger.
 		messages, merger, err := m.Split(state.layout)
 		if err != nil {
 			return nil, err
 		}
 		promises := make([]promise, len(messages))
 		for i, m := range messages {
 			promises[i] = p.sendRequest(ctx, m, state)
 		}
 		response = join(promises, messages, merger)
 	}
 
 	if response == nil {
 		response = p.sendRequest(ctx, req, state)
 	}
 
 	return response.await(ctx)
 }