diff --git a/api_test.go b/api_test.go
index dc8766dd..48dbc37f 100644
--- a/api_test.go
+++ b/api_test.go
@@ -254,13 +254,13 @@ var _ = Describe("Service Broker API", func() {
 	Describe("OriginatingIdentityHeader", func() {
 
 		var (
-			fakeServiceBroker *fakes.AutoFakeServiceBrokerNew
+			fakeServiceBroker *fakes.AutoFakeServiceBroker
 			req               *http.Request
 			testServer        *httptest.Server
 		)
 
 		BeforeEach(func() {
-			fakeServiceBroker = new(fakes.AutoFakeServiceBrokerNew)
+			fakeServiceBroker = new(fakes.AutoFakeServiceBroker)
 			brokerAPI = brokerapi.New(fakeServiceBroker, brokerLogger, credentials)
 
 			testServer = httptest.NewServer(brokerAPI)
@@ -1400,7 +1400,7 @@ var _ = Describe("Service Broker API", func() {
 
 	Describe("binding lifecycle endpoint", func() {
 
-		makeLastBindingOperationRequestWithSpecificAPIVersion := func(instanceID, bindingID string, apiVersion string) *testflight.Response {
+		makeLastBindingOperationRequest := func(instanceID, bindingID string) *testflight.Response {
 			response := &testflight.Response{}
 			testflight.WithServer(brokerAPI, func(r *testflight.Requester) {
 				path := fmt.Sprintf("/v2/service_instances/%s/service_bindings/%s/last_operation", instanceID, bindingID)
@@ -1411,9 +1411,7 @@ var _ = Describe("Service Broker API", func() {
 
 				Expect(err).NotTo(HaveOccurred())
 
-				if apiVersion != "" {
-					request.Header.Add("X-Broker-Api-Version", apiVersion)
-				}
+				request.Header.Add("X-Broker-Api-Version", "2.14")
 				request.Header.Add("Content-Type", "application/json")
 				request.SetBasicAuth("username", "password")
 
@@ -1836,14 +1834,6 @@ var _ = Describe("Service Broker API", func() {
 						Expect(response.Body).To(MatchJSON(fixture("binding.json")))
 					})
 
-					It("fails for LastBindingOperation request", func() {
-						response := makeLastBindingOperationRequestWithSpecificAPIVersion(instanceID, bindingID, "1.13")
-						Expect(response.StatusCode).To(Equal(http.StatusPreconditionFailed))
-						response = makeLastBindingOperationRequestWithSpecificAPIVersion(instanceID, bindingID, "2.13")
-						Expect(response.StatusCode).To(Equal(http.StatusPreconditionFailed))
-						Expect(response.Body).To(MatchJSON(`{"description":"get binding endpoint only supported starting with OSB version 2.14"}`))
-					})
-
 					It("fails for GetBinding request", func() {
 						response := makeGetBindingRequestWithSpecificAPIVersion(instanceID, bindingID, "1.13")
 						Expect(response.StatusCode).To(Equal(http.StatusPreconditionFailed))
@@ -1862,7 +1852,7 @@ var _ = Describe("Service Broker API", func() {
 					It("can be polled with lastBindingOperation", func() {
 						fakeAsyncServiceBroker.LastOperationState = "succeeded"
 						fakeAsyncServiceBroker.LastOperationDescription = "some description"
-						response := makeLastBindingOperationRequestWithSpecificAPIVersion(instanceID, bindingID, "2.14")
+						response := makeLastBindingOperationRequest(instanceID, bindingID)
 						Expect(response.StatusCode).To(Equal(http.StatusOK))
 						Expect(response.Body).To(MatchJSON(fixture("last_operation_succeeded.json")))
 					})
@@ -1872,23 +1862,6 @@ var _ = Describe("Service Broker API", func() {
 						Expect(response.StatusCode).To(Equal(http.StatusOK))
 						Expect(response.Body).To(MatchJSON(fixture("binding.json")))
 					})
-
-					It("returns 500 when lastBindingOperation returns an unknown error", func() {
-						fakeAsyncServiceBroker.LastBindingOperationError = errors.New("unknown error")
-
-						response := makeLastBindingOperationRequestWithSpecificAPIVersion(instanceID, bindingID, "2.14")
-						Expect(response.StatusCode).To(Equal(http.StatusInternalServerError))
-					})
-
-					It("returns the appropriate when lastBindingOperation returns a known error", func() {
-						fakeAsyncServiceBroker.LastBindingOperationError = brokerapi.NewFailureResponse(
-							errors.New("I failed in unique and interesting ways"),
-							http.StatusTeapot,
-							"interesting-failure",
-						)
-						response := makeLastBindingOperationRequestWithSpecificAPIVersion(instanceID, bindingID, "2.14")
-						Expect(response.StatusCode).To(Equal(http.StatusTeapot))
-					})
 				})
 			})
 		})
diff --git a/domain/service_broker.go b/domain/service_broker.go
index 3f7d8b80..8882256d 100644
--- a/domain/service_broker.go
+++ b/domain/service_broker.go
@@ -5,7 +5,7 @@ import (
 	"encoding/json"
 )
 
-//go:generate counterfeiter -o ../fakes/auto_fake_service_broker_new.go -fake-name AutoFakeServiceBrokerNew . ServiceBroker
+//go:generate counterfeiter -o ../fakes/auto_fake_service_broker.go -fake-name AutoFakeServiceBroker . ServiceBroker
 
 //Each method of the ServiceBroker interface maps to an individual endpoint of the Open Service Broker API.
 //The specification is available here: https://github.com/openservicebrokerapi/servicebroker/blob/v2.14/spec.md
@@ -54,8 +54,8 @@ type ServiceBroker interface {
 }
 
 type LastOperation struct {
-	State       LastOperationState
-	Description string
+	State       LastOperationState `json:"state"`
+	Description string `json:"description"`
 }
 
 type LastOperationState string
diff --git a/fakes/auto_fake_service_broker.go b/fakes/auto_fake_service_broker.go
index b3d02020..34b6ec78 100644
--- a/fakes/auto_fake_service_broker.go
+++ b/fakes/auto_fake_service_broker.go
@@ -5,7 +5,6 @@ import (
 	"context"
 	"sync"
 
-	"github.com/pivotal-cf/brokerapi"
 	"github.com/pivotal-cf/brokerapi/domain"
 )
 
@@ -866,4 +865,4 @@ func (fake *AutoFakeServiceBroker) recordInvocation(key string, args []interface
 	fake.invocations[key] = append(fake.invocations[key], args)
 }
 
-var _ brokerapi.ServiceBroker = new(AutoFakeServiceBroker)
+var _ domain.ServiceBroker = new(AutoFakeServiceBroker)
diff --git a/fakes/auto_fake_service_broker_new.go b/fakes/auto_fake_service_broker_new.go
deleted file mode 100644
index 755aafd5..00000000
--- a/fakes/auto_fake_service_broker_new.go
+++ /dev/null
@@ -1,868 +0,0 @@
-// Code generated by counterfeiter. DO NOT EDIT.
-package fakes
-
-import (
-	"context"
-	"sync"
-
-	"github.com/pivotal-cf/brokerapi/domain"
-)
-
-type AutoFakeServiceBrokerNew struct {
-	BindStub        func(context.Context, string, string, domain.BindDetails, bool) (domain.Binding, error)
-	bindMutex       sync.RWMutex
-	bindArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 domain.BindDetails
-		arg5 bool
-	}
-	bindReturns struct {
-		result1 domain.Binding
-		result2 error
-	}
-	bindReturnsOnCall map[int]struct {
-		result1 domain.Binding
-		result2 error
-	}
-	DeprovisionStub        func(context.Context, string, domain.DeprovisionDetails, bool) (domain.DeprovisionServiceSpec, error)
-	deprovisionMutex       sync.RWMutex
-	deprovisionArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-		arg3 domain.DeprovisionDetails
-		arg4 bool
-	}
-	deprovisionReturns struct {
-		result1 domain.DeprovisionServiceSpec
-		result2 error
-	}
-	deprovisionReturnsOnCall map[int]struct {
-		result1 domain.DeprovisionServiceSpec
-		result2 error
-	}
-	GetBindingStub        func(context.Context, string, string) (domain.GetBindingSpec, error)
-	getBindingMutex       sync.RWMutex
-	getBindingArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-	}
-	getBindingReturns struct {
-		result1 domain.GetBindingSpec
-		result2 error
-	}
-	getBindingReturnsOnCall map[int]struct {
-		result1 domain.GetBindingSpec
-		result2 error
-	}
-	GetInstanceStub        func(context.Context, string) (domain.GetInstanceDetailsSpec, error)
-	getInstanceMutex       sync.RWMutex
-	getInstanceArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-	}
-	getInstanceReturns struct {
-		result1 domain.GetInstanceDetailsSpec
-		result2 error
-	}
-	getInstanceReturnsOnCall map[int]struct {
-		result1 domain.GetInstanceDetailsSpec
-		result2 error
-	}
-	LastBindingOperationStub        func(context.Context, string, string, domain.PollDetails) (domain.LastOperation, error)
-	lastBindingOperationMutex       sync.RWMutex
-	lastBindingOperationArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 domain.PollDetails
-	}
-	lastBindingOperationReturns struct {
-		result1 domain.LastOperation
-		result2 error
-	}
-	lastBindingOperationReturnsOnCall map[int]struct {
-		result1 domain.LastOperation
-		result2 error
-	}
-	LastOperationStub        func(context.Context, string, domain.PollDetails) (domain.LastOperation, error)
-	lastOperationMutex       sync.RWMutex
-	lastOperationArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-		arg3 domain.PollDetails
-	}
-	lastOperationReturns struct {
-		result1 domain.LastOperation
-		result2 error
-	}
-	lastOperationReturnsOnCall map[int]struct {
-		result1 domain.LastOperation
-		result2 error
-	}
-	ProvisionStub        func(context.Context, string, domain.ProvisionDetails, bool) (domain.ProvisionedServiceSpec, error)
-	provisionMutex       sync.RWMutex
-	provisionArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-		arg3 domain.ProvisionDetails
-		arg4 bool
-	}
-	provisionReturns struct {
-		result1 domain.ProvisionedServiceSpec
-		result2 error
-	}
-	provisionReturnsOnCall map[int]struct {
-		result1 domain.ProvisionedServiceSpec
-		result2 error
-	}
-	ServicesStub        func(context.Context) ([]domain.Service, error)
-	servicesMutex       sync.RWMutex
-	servicesArgsForCall []struct {
-		arg1 context.Context
-	}
-	servicesReturns struct {
-		result1 []domain.Service
-		result2 error
-	}
-	servicesReturnsOnCall map[int]struct {
-		result1 []domain.Service
-		result2 error
-	}
-	UnbindStub        func(context.Context, string, string, domain.UnbindDetails, bool) (domain.UnbindSpec, error)
-	unbindMutex       sync.RWMutex
-	unbindArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 domain.UnbindDetails
-		arg5 bool
-	}
-	unbindReturns struct {
-		result1 domain.UnbindSpec
-		result2 error
-	}
-	unbindReturnsOnCall map[int]struct {
-		result1 domain.UnbindSpec
-		result2 error
-	}
-	UpdateStub        func(context.Context, string, domain.UpdateDetails, bool) (domain.UpdateServiceSpec, error)
-	updateMutex       sync.RWMutex
-	updateArgsForCall []struct {
-		arg1 context.Context
-		arg2 string
-		arg3 domain.UpdateDetails
-		arg4 bool
-	}
-	updateReturns struct {
-		result1 domain.UpdateServiceSpec
-		result2 error
-	}
-	updateReturnsOnCall map[int]struct {
-		result1 domain.UpdateServiceSpec
-		result2 error
-	}
-	invocations      map[string][][]interface{}
-	invocationsMutex sync.RWMutex
-}
-
-func (fake *AutoFakeServiceBrokerNew) Bind(arg1 context.Context, arg2 string, arg3 string, arg4 domain.BindDetails, arg5 bool) (domain.Binding, error) {
-	fake.bindMutex.Lock()
-	ret, specificReturn := fake.bindReturnsOnCall[len(fake.bindArgsForCall)]
-	fake.bindArgsForCall = append(fake.bindArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 domain.BindDetails
-		arg5 bool
-	}{arg1, arg2, arg3, arg4, arg5})
-	fake.recordInvocation("Bind", []interface{}{arg1, arg2, arg3, arg4, arg5})
-	fake.bindMutex.Unlock()
-	if fake.BindStub != nil {
-		return fake.BindStub(arg1, arg2, arg3, arg4, arg5)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.bindReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *AutoFakeServiceBrokerNew) BindCallCount() int {
-	fake.bindMutex.RLock()
-	defer fake.bindMutex.RUnlock()
-	return len(fake.bindArgsForCall)
-}
-
-func (fake *AutoFakeServiceBrokerNew) BindCalls(stub func(context.Context, string, string, domain.BindDetails, bool) (domain.Binding, error)) {
-	fake.bindMutex.Lock()
-	defer fake.bindMutex.Unlock()
-	fake.BindStub = stub
-}
-
-func (fake *AutoFakeServiceBrokerNew) BindArgsForCall(i int) (context.Context, string, string, domain.BindDetails, bool) {
-	fake.bindMutex.RLock()
-	defer fake.bindMutex.RUnlock()
-	argsForCall := fake.bindArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
-}
-
-func (fake *AutoFakeServiceBrokerNew) BindReturns(result1 domain.Binding, result2 error) {
-	fake.bindMutex.Lock()
-	defer fake.bindMutex.Unlock()
-	fake.BindStub = nil
-	fake.bindReturns = struct {
-		result1 domain.Binding
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) BindReturnsOnCall(i int, result1 domain.Binding, result2 error) {
-	fake.bindMutex.Lock()
-	defer fake.bindMutex.Unlock()
-	fake.BindStub = nil
-	if fake.bindReturnsOnCall == nil {
-		fake.bindReturnsOnCall = make(map[int]struct {
-			result1 domain.Binding
-			result2 error
-		})
-	}
-	fake.bindReturnsOnCall[i] = struct {
-		result1 domain.Binding
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) Deprovision(arg1 context.Context, arg2 string, arg3 domain.DeprovisionDetails, arg4 bool) (domain.DeprovisionServiceSpec, error) {
-	fake.deprovisionMutex.Lock()
-	ret, specificReturn := fake.deprovisionReturnsOnCall[len(fake.deprovisionArgsForCall)]
-	fake.deprovisionArgsForCall = append(fake.deprovisionArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-		arg3 domain.DeprovisionDetails
-		arg4 bool
-	}{arg1, arg2, arg3, arg4})
-	fake.recordInvocation("Deprovision", []interface{}{arg1, arg2, arg3, arg4})
-	fake.deprovisionMutex.Unlock()
-	if fake.DeprovisionStub != nil {
-		return fake.DeprovisionStub(arg1, arg2, arg3, arg4)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.deprovisionReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *AutoFakeServiceBrokerNew) DeprovisionCallCount() int {
-	fake.deprovisionMutex.RLock()
-	defer fake.deprovisionMutex.RUnlock()
-	return len(fake.deprovisionArgsForCall)
-}
-
-func (fake *AutoFakeServiceBrokerNew) DeprovisionCalls(stub func(context.Context, string, domain.DeprovisionDetails, bool) (domain.DeprovisionServiceSpec, error)) {
-	fake.deprovisionMutex.Lock()
-	defer fake.deprovisionMutex.Unlock()
-	fake.DeprovisionStub = stub
-}
-
-func (fake *AutoFakeServiceBrokerNew) DeprovisionArgsForCall(i int) (context.Context, string, domain.DeprovisionDetails, bool) {
-	fake.deprovisionMutex.RLock()
-	defer fake.deprovisionMutex.RUnlock()
-	argsForCall := fake.deprovisionArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
-}
-
-func (fake *AutoFakeServiceBrokerNew) DeprovisionReturns(result1 domain.DeprovisionServiceSpec, result2 error) {
-	fake.deprovisionMutex.Lock()
-	defer fake.deprovisionMutex.Unlock()
-	fake.DeprovisionStub = nil
-	fake.deprovisionReturns = struct {
-		result1 domain.DeprovisionServiceSpec
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) DeprovisionReturnsOnCall(i int, result1 domain.DeprovisionServiceSpec, result2 error) {
-	fake.deprovisionMutex.Lock()
-	defer fake.deprovisionMutex.Unlock()
-	fake.DeprovisionStub = nil
-	if fake.deprovisionReturnsOnCall == nil {
-		fake.deprovisionReturnsOnCall = make(map[int]struct {
-			result1 domain.DeprovisionServiceSpec
-			result2 error
-		})
-	}
-	fake.deprovisionReturnsOnCall[i] = struct {
-		result1 domain.DeprovisionServiceSpec
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) GetBinding(arg1 context.Context, arg2 string, arg3 string) (domain.GetBindingSpec, error) {
-	fake.getBindingMutex.Lock()
-	ret, specificReturn := fake.getBindingReturnsOnCall[len(fake.getBindingArgsForCall)]
-	fake.getBindingArgsForCall = append(fake.getBindingArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-	}{arg1, arg2, arg3})
-	fake.recordInvocation("GetBinding", []interface{}{arg1, arg2, arg3})
-	fake.getBindingMutex.Unlock()
-	if fake.GetBindingStub != nil {
-		return fake.GetBindingStub(arg1, arg2, arg3)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.getBindingReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *AutoFakeServiceBrokerNew) GetBindingCallCount() int {
-	fake.getBindingMutex.RLock()
-	defer fake.getBindingMutex.RUnlock()
-	return len(fake.getBindingArgsForCall)
-}
-
-func (fake *AutoFakeServiceBrokerNew) GetBindingCalls(stub func(context.Context, string, string) (domain.GetBindingSpec, error)) {
-	fake.getBindingMutex.Lock()
-	defer fake.getBindingMutex.Unlock()
-	fake.GetBindingStub = stub
-}
-
-func (fake *AutoFakeServiceBrokerNew) GetBindingArgsForCall(i int) (context.Context, string, string) {
-	fake.getBindingMutex.RLock()
-	defer fake.getBindingMutex.RUnlock()
-	argsForCall := fake.getBindingArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *AutoFakeServiceBrokerNew) GetBindingReturns(result1 domain.GetBindingSpec, result2 error) {
-	fake.getBindingMutex.Lock()
-	defer fake.getBindingMutex.Unlock()
-	fake.GetBindingStub = nil
-	fake.getBindingReturns = struct {
-		result1 domain.GetBindingSpec
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) GetBindingReturnsOnCall(i int, result1 domain.GetBindingSpec, result2 error) {
-	fake.getBindingMutex.Lock()
-	defer fake.getBindingMutex.Unlock()
-	fake.GetBindingStub = nil
-	if fake.getBindingReturnsOnCall == nil {
-		fake.getBindingReturnsOnCall = make(map[int]struct {
-			result1 domain.GetBindingSpec
-			result2 error
-		})
-	}
-	fake.getBindingReturnsOnCall[i] = struct {
-		result1 domain.GetBindingSpec
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) GetInstance(arg1 context.Context, arg2 string) (domain.GetInstanceDetailsSpec, error) {
-	fake.getInstanceMutex.Lock()
-	ret, specificReturn := fake.getInstanceReturnsOnCall[len(fake.getInstanceArgsForCall)]
-	fake.getInstanceArgsForCall = append(fake.getInstanceArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-	}{arg1, arg2})
-	fake.recordInvocation("GetInstance", []interface{}{arg1, arg2})
-	fake.getInstanceMutex.Unlock()
-	if fake.GetInstanceStub != nil {
-		return fake.GetInstanceStub(arg1, arg2)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.getInstanceReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *AutoFakeServiceBrokerNew) GetInstanceCallCount() int {
-	fake.getInstanceMutex.RLock()
-	defer fake.getInstanceMutex.RUnlock()
-	return len(fake.getInstanceArgsForCall)
-}
-
-func (fake *AutoFakeServiceBrokerNew) GetInstanceCalls(stub func(context.Context, string) (domain.GetInstanceDetailsSpec, error)) {
-	fake.getInstanceMutex.Lock()
-	defer fake.getInstanceMutex.Unlock()
-	fake.GetInstanceStub = stub
-}
-
-func (fake *AutoFakeServiceBrokerNew) GetInstanceArgsForCall(i int) (context.Context, string) {
-	fake.getInstanceMutex.RLock()
-	defer fake.getInstanceMutex.RUnlock()
-	argsForCall := fake.getInstanceArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2
-}
-
-func (fake *AutoFakeServiceBrokerNew) GetInstanceReturns(result1 domain.GetInstanceDetailsSpec, result2 error) {
-	fake.getInstanceMutex.Lock()
-	defer fake.getInstanceMutex.Unlock()
-	fake.GetInstanceStub = nil
-	fake.getInstanceReturns = struct {
-		result1 domain.GetInstanceDetailsSpec
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) GetInstanceReturnsOnCall(i int, result1 domain.GetInstanceDetailsSpec, result2 error) {
-	fake.getInstanceMutex.Lock()
-	defer fake.getInstanceMutex.Unlock()
-	fake.GetInstanceStub = nil
-	if fake.getInstanceReturnsOnCall == nil {
-		fake.getInstanceReturnsOnCall = make(map[int]struct {
-			result1 domain.GetInstanceDetailsSpec
-			result2 error
-		})
-	}
-	fake.getInstanceReturnsOnCall[i] = struct {
-		result1 domain.GetInstanceDetailsSpec
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) LastBindingOperation(arg1 context.Context, arg2 string, arg3 string, arg4 domain.PollDetails) (domain.LastOperation, error) {
-	fake.lastBindingOperationMutex.Lock()
-	ret, specificReturn := fake.lastBindingOperationReturnsOnCall[len(fake.lastBindingOperationArgsForCall)]
-	fake.lastBindingOperationArgsForCall = append(fake.lastBindingOperationArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 domain.PollDetails
-	}{arg1, arg2, arg3, arg4})
-	fake.recordInvocation("LastBindingOperation", []interface{}{arg1, arg2, arg3, arg4})
-	fake.lastBindingOperationMutex.Unlock()
-	if fake.LastBindingOperationStub != nil {
-		return fake.LastBindingOperationStub(arg1, arg2, arg3, arg4)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.lastBindingOperationReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *AutoFakeServiceBrokerNew) LastBindingOperationCallCount() int {
-	fake.lastBindingOperationMutex.RLock()
-	defer fake.lastBindingOperationMutex.RUnlock()
-	return len(fake.lastBindingOperationArgsForCall)
-}
-
-func (fake *AutoFakeServiceBrokerNew) LastBindingOperationCalls(stub func(context.Context, string, string, domain.PollDetails) (domain.LastOperation, error)) {
-	fake.lastBindingOperationMutex.Lock()
-	defer fake.lastBindingOperationMutex.Unlock()
-	fake.LastBindingOperationStub = stub
-}
-
-func (fake *AutoFakeServiceBrokerNew) LastBindingOperationArgsForCall(i int) (context.Context, string, string, domain.PollDetails) {
-	fake.lastBindingOperationMutex.RLock()
-	defer fake.lastBindingOperationMutex.RUnlock()
-	argsForCall := fake.lastBindingOperationArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
-}
-
-func (fake *AutoFakeServiceBrokerNew) LastBindingOperationReturns(result1 domain.LastOperation, result2 error) {
-	fake.lastBindingOperationMutex.Lock()
-	defer fake.lastBindingOperationMutex.Unlock()
-	fake.LastBindingOperationStub = nil
-	fake.lastBindingOperationReturns = struct {
-		result1 domain.LastOperation
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) LastBindingOperationReturnsOnCall(i int, result1 domain.LastOperation, result2 error) {
-	fake.lastBindingOperationMutex.Lock()
-	defer fake.lastBindingOperationMutex.Unlock()
-	fake.LastBindingOperationStub = nil
-	if fake.lastBindingOperationReturnsOnCall == nil {
-		fake.lastBindingOperationReturnsOnCall = make(map[int]struct {
-			result1 domain.LastOperation
-			result2 error
-		})
-	}
-	fake.lastBindingOperationReturnsOnCall[i] = struct {
-		result1 domain.LastOperation
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) LastOperation(arg1 context.Context, arg2 string, arg3 domain.PollDetails) (domain.LastOperation, error) {
-	fake.lastOperationMutex.Lock()
-	ret, specificReturn := fake.lastOperationReturnsOnCall[len(fake.lastOperationArgsForCall)]
-	fake.lastOperationArgsForCall = append(fake.lastOperationArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-		arg3 domain.PollDetails
-	}{arg1, arg2, arg3})
-	fake.recordInvocation("LastOperation", []interface{}{arg1, arg2, arg3})
-	fake.lastOperationMutex.Unlock()
-	if fake.LastOperationStub != nil {
-		return fake.LastOperationStub(arg1, arg2, arg3)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.lastOperationReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *AutoFakeServiceBrokerNew) LastOperationCallCount() int {
-	fake.lastOperationMutex.RLock()
-	defer fake.lastOperationMutex.RUnlock()
-	return len(fake.lastOperationArgsForCall)
-}
-
-func (fake *AutoFakeServiceBrokerNew) LastOperationCalls(stub func(context.Context, string, domain.PollDetails) (domain.LastOperation, error)) {
-	fake.lastOperationMutex.Lock()
-	defer fake.lastOperationMutex.Unlock()
-	fake.LastOperationStub = stub
-}
-
-func (fake *AutoFakeServiceBrokerNew) LastOperationArgsForCall(i int) (context.Context, string, domain.PollDetails) {
-	fake.lastOperationMutex.RLock()
-	defer fake.lastOperationMutex.RUnlock()
-	argsForCall := fake.lastOperationArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
-}
-
-func (fake *AutoFakeServiceBrokerNew) LastOperationReturns(result1 domain.LastOperation, result2 error) {
-	fake.lastOperationMutex.Lock()
-	defer fake.lastOperationMutex.Unlock()
-	fake.LastOperationStub = nil
-	fake.lastOperationReturns = struct {
-		result1 domain.LastOperation
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) LastOperationReturnsOnCall(i int, result1 domain.LastOperation, result2 error) {
-	fake.lastOperationMutex.Lock()
-	defer fake.lastOperationMutex.Unlock()
-	fake.LastOperationStub = nil
-	if fake.lastOperationReturnsOnCall == nil {
-		fake.lastOperationReturnsOnCall = make(map[int]struct {
-			result1 domain.LastOperation
-			result2 error
-		})
-	}
-	fake.lastOperationReturnsOnCall[i] = struct {
-		result1 domain.LastOperation
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) Provision(arg1 context.Context, arg2 string, arg3 domain.ProvisionDetails, arg4 bool) (domain.ProvisionedServiceSpec, error) {
-	fake.provisionMutex.Lock()
-	ret, specificReturn := fake.provisionReturnsOnCall[len(fake.provisionArgsForCall)]
-	fake.provisionArgsForCall = append(fake.provisionArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-		arg3 domain.ProvisionDetails
-		arg4 bool
-	}{arg1, arg2, arg3, arg4})
-	fake.recordInvocation("Provision", []interface{}{arg1, arg2, arg3, arg4})
-	fake.provisionMutex.Unlock()
-	if fake.ProvisionStub != nil {
-		return fake.ProvisionStub(arg1, arg2, arg3, arg4)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.provisionReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *AutoFakeServiceBrokerNew) ProvisionCallCount() int {
-	fake.provisionMutex.RLock()
-	defer fake.provisionMutex.RUnlock()
-	return len(fake.provisionArgsForCall)
-}
-
-func (fake *AutoFakeServiceBrokerNew) ProvisionCalls(stub func(context.Context, string, domain.ProvisionDetails, bool) (domain.ProvisionedServiceSpec, error)) {
-	fake.provisionMutex.Lock()
-	defer fake.provisionMutex.Unlock()
-	fake.ProvisionStub = stub
-}
-
-func (fake *AutoFakeServiceBrokerNew) ProvisionArgsForCall(i int) (context.Context, string, domain.ProvisionDetails, bool) {
-	fake.provisionMutex.RLock()
-	defer fake.provisionMutex.RUnlock()
-	argsForCall := fake.provisionArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
-}
-
-func (fake *AutoFakeServiceBrokerNew) ProvisionReturns(result1 domain.ProvisionedServiceSpec, result2 error) {
-	fake.provisionMutex.Lock()
-	defer fake.provisionMutex.Unlock()
-	fake.ProvisionStub = nil
-	fake.provisionReturns = struct {
-		result1 domain.ProvisionedServiceSpec
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) ProvisionReturnsOnCall(i int, result1 domain.ProvisionedServiceSpec, result2 error) {
-	fake.provisionMutex.Lock()
-	defer fake.provisionMutex.Unlock()
-	fake.ProvisionStub = nil
-	if fake.provisionReturnsOnCall == nil {
-		fake.provisionReturnsOnCall = make(map[int]struct {
-			result1 domain.ProvisionedServiceSpec
-			result2 error
-		})
-	}
-	fake.provisionReturnsOnCall[i] = struct {
-		result1 domain.ProvisionedServiceSpec
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) Services(arg1 context.Context) ([]domain.Service, error) {
-	fake.servicesMutex.Lock()
-	ret, specificReturn := fake.servicesReturnsOnCall[len(fake.servicesArgsForCall)]
-	fake.servicesArgsForCall = append(fake.servicesArgsForCall, struct {
-		arg1 context.Context
-	}{arg1})
-	fake.recordInvocation("Services", []interface{}{arg1})
-	fake.servicesMutex.Unlock()
-	if fake.ServicesStub != nil {
-		return fake.ServicesStub(arg1)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.servicesReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *AutoFakeServiceBrokerNew) ServicesCallCount() int {
-	fake.servicesMutex.RLock()
-	defer fake.servicesMutex.RUnlock()
-	return len(fake.servicesArgsForCall)
-}
-
-func (fake *AutoFakeServiceBrokerNew) ServicesCalls(stub func(context.Context) ([]domain.Service, error)) {
-	fake.servicesMutex.Lock()
-	defer fake.servicesMutex.Unlock()
-	fake.ServicesStub = stub
-}
-
-func (fake *AutoFakeServiceBrokerNew) ServicesArgsForCall(i int) context.Context {
-	fake.servicesMutex.RLock()
-	defer fake.servicesMutex.RUnlock()
-	argsForCall := fake.servicesArgsForCall[i]
-	return argsForCall.arg1
-}
-
-func (fake *AutoFakeServiceBrokerNew) ServicesReturns(result1 []domain.Service, result2 error) {
-	fake.servicesMutex.Lock()
-	defer fake.servicesMutex.Unlock()
-	fake.ServicesStub = nil
-	fake.servicesReturns = struct {
-		result1 []domain.Service
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) ServicesReturnsOnCall(i int, result1 []domain.Service, result2 error) {
-	fake.servicesMutex.Lock()
-	defer fake.servicesMutex.Unlock()
-	fake.ServicesStub = nil
-	if fake.servicesReturnsOnCall == nil {
-		fake.servicesReturnsOnCall = make(map[int]struct {
-			result1 []domain.Service
-			result2 error
-		})
-	}
-	fake.servicesReturnsOnCall[i] = struct {
-		result1 []domain.Service
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) Unbind(arg1 context.Context, arg2 string, arg3 string, arg4 domain.UnbindDetails, arg5 bool) (domain.UnbindSpec, error) {
-	fake.unbindMutex.Lock()
-	ret, specificReturn := fake.unbindReturnsOnCall[len(fake.unbindArgsForCall)]
-	fake.unbindArgsForCall = append(fake.unbindArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-		arg3 string
-		arg4 domain.UnbindDetails
-		arg5 bool
-	}{arg1, arg2, arg3, arg4, arg5})
-	fake.recordInvocation("Unbind", []interface{}{arg1, arg2, arg3, arg4, arg5})
-	fake.unbindMutex.Unlock()
-	if fake.UnbindStub != nil {
-		return fake.UnbindStub(arg1, arg2, arg3, arg4, arg5)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.unbindReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *AutoFakeServiceBrokerNew) UnbindCallCount() int {
-	fake.unbindMutex.RLock()
-	defer fake.unbindMutex.RUnlock()
-	return len(fake.unbindArgsForCall)
-}
-
-func (fake *AutoFakeServiceBrokerNew) UnbindCalls(stub func(context.Context, string, string, domain.UnbindDetails, bool) (domain.UnbindSpec, error)) {
-	fake.unbindMutex.Lock()
-	defer fake.unbindMutex.Unlock()
-	fake.UnbindStub = stub
-}
-
-func (fake *AutoFakeServiceBrokerNew) UnbindArgsForCall(i int) (context.Context, string, string, domain.UnbindDetails, bool) {
-	fake.unbindMutex.RLock()
-	defer fake.unbindMutex.RUnlock()
-	argsForCall := fake.unbindArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4, argsForCall.arg5
-}
-
-func (fake *AutoFakeServiceBrokerNew) UnbindReturns(result1 domain.UnbindSpec, result2 error) {
-	fake.unbindMutex.Lock()
-	defer fake.unbindMutex.Unlock()
-	fake.UnbindStub = nil
-	fake.unbindReturns = struct {
-		result1 domain.UnbindSpec
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) UnbindReturnsOnCall(i int, result1 domain.UnbindSpec, result2 error) {
-	fake.unbindMutex.Lock()
-	defer fake.unbindMutex.Unlock()
-	fake.UnbindStub = nil
-	if fake.unbindReturnsOnCall == nil {
-		fake.unbindReturnsOnCall = make(map[int]struct {
-			result1 domain.UnbindSpec
-			result2 error
-		})
-	}
-	fake.unbindReturnsOnCall[i] = struct {
-		result1 domain.UnbindSpec
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) Update(arg1 context.Context, arg2 string, arg3 domain.UpdateDetails, arg4 bool) (domain.UpdateServiceSpec, error) {
-	fake.updateMutex.Lock()
-	ret, specificReturn := fake.updateReturnsOnCall[len(fake.updateArgsForCall)]
-	fake.updateArgsForCall = append(fake.updateArgsForCall, struct {
-		arg1 context.Context
-		arg2 string
-		arg3 domain.UpdateDetails
-		arg4 bool
-	}{arg1, arg2, arg3, arg4})
-	fake.recordInvocation("Update", []interface{}{arg1, arg2, arg3, arg4})
-	fake.updateMutex.Unlock()
-	if fake.UpdateStub != nil {
-		return fake.UpdateStub(arg1, arg2, arg3, arg4)
-	}
-	if specificReturn {
-		return ret.result1, ret.result2
-	}
-	fakeReturns := fake.updateReturns
-	return fakeReturns.result1, fakeReturns.result2
-}
-
-func (fake *AutoFakeServiceBrokerNew) UpdateCallCount() int {
-	fake.updateMutex.RLock()
-	defer fake.updateMutex.RUnlock()
-	return len(fake.updateArgsForCall)
-}
-
-func (fake *AutoFakeServiceBrokerNew) UpdateCalls(stub func(context.Context, string, domain.UpdateDetails, bool) (domain.UpdateServiceSpec, error)) {
-	fake.updateMutex.Lock()
-	defer fake.updateMutex.Unlock()
-	fake.UpdateStub = stub
-}
-
-func (fake *AutoFakeServiceBrokerNew) UpdateArgsForCall(i int) (context.Context, string, domain.UpdateDetails, bool) {
-	fake.updateMutex.RLock()
-	defer fake.updateMutex.RUnlock()
-	argsForCall := fake.updateArgsForCall[i]
-	return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4
-}
-
-func (fake *AutoFakeServiceBrokerNew) UpdateReturns(result1 domain.UpdateServiceSpec, result2 error) {
-	fake.updateMutex.Lock()
-	defer fake.updateMutex.Unlock()
-	fake.UpdateStub = nil
-	fake.updateReturns = struct {
-		result1 domain.UpdateServiceSpec
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) UpdateReturnsOnCall(i int, result1 domain.UpdateServiceSpec, result2 error) {
-	fake.updateMutex.Lock()
-	defer fake.updateMutex.Unlock()
-	fake.UpdateStub = nil
-	if fake.updateReturnsOnCall == nil {
-		fake.updateReturnsOnCall = make(map[int]struct {
-			result1 domain.UpdateServiceSpec
-			result2 error
-		})
-	}
-	fake.updateReturnsOnCall[i] = struct {
-		result1 domain.UpdateServiceSpec
-		result2 error
-	}{result1, result2}
-}
-
-func (fake *AutoFakeServiceBrokerNew) Invocations() map[string][][]interface{} {
-	fake.invocationsMutex.RLock()
-	defer fake.invocationsMutex.RUnlock()
-	fake.bindMutex.RLock()
-	defer fake.bindMutex.RUnlock()
-	fake.deprovisionMutex.RLock()
-	defer fake.deprovisionMutex.RUnlock()
-	fake.getBindingMutex.RLock()
-	defer fake.getBindingMutex.RUnlock()
-	fake.getInstanceMutex.RLock()
-	defer fake.getInstanceMutex.RUnlock()
-	fake.lastBindingOperationMutex.RLock()
-	defer fake.lastBindingOperationMutex.RUnlock()
-	fake.lastOperationMutex.RLock()
-	defer fake.lastOperationMutex.RUnlock()
-	fake.provisionMutex.RLock()
-	defer fake.provisionMutex.RUnlock()
-	fake.servicesMutex.RLock()
-	defer fake.servicesMutex.RUnlock()
-	fake.unbindMutex.RLock()
-	defer fake.unbindMutex.RUnlock()
-	fake.updateMutex.RLock()
-	defer fake.updateMutex.RUnlock()
-	copiedInvocations := map[string][][]interface{}{}
-	for key, value := range fake.invocations {
-		copiedInvocations[key] = value
-	}
-	return copiedInvocations
-}
-
-func (fake *AutoFakeServiceBrokerNew) recordInvocation(key string, args []interface{}) {
-	fake.invocationsMutex.Lock()
-	defer fake.invocationsMutex.Unlock()
-	if fake.invocations == nil {
-		fake.invocations = map[string][][]interface{}{}
-	}
-	if fake.invocations[key] == nil {
-		fake.invocations[key] = [][]interface{}{}
-	}
-	fake.invocations[key] = append(fake.invocations[key], args)
-}
-
-var _ domain.ServiceBroker = new(AutoFakeServiceBrokerNew)
diff --git a/handlers/fakes/fake_response_writer.go b/handlers/fakes/fake_response_writer.go
new file mode 100644
index 00000000..f135b080
--- /dev/null
+++ b/handlers/fakes/fake_response_writer.go
@@ -0,0 +1,221 @@
+// Code generated by counterfeiter. DO NOT EDIT.
+package fakes
+
+import (
+	"net/http"
+	"sync"
+)
+
+type FakeResponseWriter struct {
+	HeaderStub        func() http.Header
+	headerMutex       sync.RWMutex
+	headerArgsForCall []struct {
+	}
+	headerReturns struct {
+		result1 http.Header
+	}
+	headerReturnsOnCall map[int]struct {
+		result1 http.Header
+	}
+	WriteStub        func([]byte) (int, error)
+	writeMutex       sync.RWMutex
+	writeArgsForCall []struct {
+		arg1 []byte
+	}
+	writeReturns struct {
+		result1 int
+		result2 error
+	}
+	writeReturnsOnCall map[int]struct {
+		result1 int
+		result2 error
+	}
+	WriteHeaderStub        func(int)
+	writeHeaderMutex       sync.RWMutex
+	writeHeaderArgsForCall []struct {
+		arg1 int
+	}
+	invocations      map[string][][]interface{}
+	invocationsMutex sync.RWMutex
+}
+
+func (fake *FakeResponseWriter) Header() http.Header {
+	fake.headerMutex.Lock()
+	ret, specificReturn := fake.headerReturnsOnCall[len(fake.headerArgsForCall)]
+	fake.headerArgsForCall = append(fake.headerArgsForCall, struct {
+	}{})
+	fake.recordInvocation("Header", []interface{}{})
+	fake.headerMutex.Unlock()
+	if fake.HeaderStub != nil {
+		return fake.HeaderStub()
+	}
+	if specificReturn {
+		return ret.result1
+	}
+	fakeReturns := fake.headerReturns
+	return fakeReturns.result1
+}
+
+func (fake *FakeResponseWriter) HeaderCallCount() int {
+	fake.headerMutex.RLock()
+	defer fake.headerMutex.RUnlock()
+	return len(fake.headerArgsForCall)
+}
+
+func (fake *FakeResponseWriter) HeaderCalls(stub func() http.Header) {
+	fake.headerMutex.Lock()
+	defer fake.headerMutex.Unlock()
+	fake.HeaderStub = stub
+}
+
+func (fake *FakeResponseWriter) HeaderReturns(result1 http.Header) {
+	fake.headerMutex.Lock()
+	defer fake.headerMutex.Unlock()
+	fake.HeaderStub = nil
+	fake.headerReturns = struct {
+		result1 http.Header
+	}{result1}
+}
+
+func (fake *FakeResponseWriter) HeaderReturnsOnCall(i int, result1 http.Header) {
+	fake.headerMutex.Lock()
+	defer fake.headerMutex.Unlock()
+	fake.HeaderStub = nil
+	if fake.headerReturnsOnCall == nil {
+		fake.headerReturnsOnCall = make(map[int]struct {
+			result1 http.Header
+		})
+	}
+	fake.headerReturnsOnCall[i] = struct {
+		result1 http.Header
+	}{result1}
+}
+
+func (fake *FakeResponseWriter) Write(arg1 []byte) (int, error) {
+	var arg1Copy []byte
+	if arg1 != nil {
+		arg1Copy = make([]byte, len(arg1))
+		copy(arg1Copy, arg1)
+	}
+	fake.writeMutex.Lock()
+	ret, specificReturn := fake.writeReturnsOnCall[len(fake.writeArgsForCall)]
+	fake.writeArgsForCall = append(fake.writeArgsForCall, struct {
+		arg1 []byte
+	}{arg1Copy})
+	fake.recordInvocation("Write", []interface{}{arg1Copy})
+	fake.writeMutex.Unlock()
+	if fake.WriteStub != nil {
+		return fake.WriteStub(arg1)
+	}
+	if specificReturn {
+		return ret.result1, ret.result2
+	}
+	fakeReturns := fake.writeReturns
+	return fakeReturns.result1, fakeReturns.result2
+}
+
+func (fake *FakeResponseWriter) WriteCallCount() int {
+	fake.writeMutex.RLock()
+	defer fake.writeMutex.RUnlock()
+	return len(fake.writeArgsForCall)
+}
+
+func (fake *FakeResponseWriter) WriteCalls(stub func([]byte) (int, error)) {
+	fake.writeMutex.Lock()
+	defer fake.writeMutex.Unlock()
+	fake.WriteStub = stub
+}
+
+func (fake *FakeResponseWriter) WriteArgsForCall(i int) []byte {
+	fake.writeMutex.RLock()
+	defer fake.writeMutex.RUnlock()
+	argsForCall := fake.writeArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeResponseWriter) WriteReturns(result1 int, result2 error) {
+	fake.writeMutex.Lock()
+	defer fake.writeMutex.Unlock()
+	fake.WriteStub = nil
+	fake.writeReturns = struct {
+		result1 int
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeResponseWriter) WriteReturnsOnCall(i int, result1 int, result2 error) {
+	fake.writeMutex.Lock()
+	defer fake.writeMutex.Unlock()
+	fake.WriteStub = nil
+	if fake.writeReturnsOnCall == nil {
+		fake.writeReturnsOnCall = make(map[int]struct {
+			result1 int
+			result2 error
+		})
+	}
+	fake.writeReturnsOnCall[i] = struct {
+		result1 int
+		result2 error
+	}{result1, result2}
+}
+
+func (fake *FakeResponseWriter) WriteHeader(arg1 int) {
+	fake.writeHeaderMutex.Lock()
+	fake.writeHeaderArgsForCall = append(fake.writeHeaderArgsForCall, struct {
+		arg1 int
+	}{arg1})
+	fake.recordInvocation("WriteHeader", []interface{}{arg1})
+	fake.writeHeaderMutex.Unlock()
+	if fake.WriteHeaderStub != nil {
+		fake.WriteHeaderStub(arg1)
+	}
+}
+
+func (fake *FakeResponseWriter) WriteHeaderCallCount() int {
+	fake.writeHeaderMutex.RLock()
+	defer fake.writeHeaderMutex.RUnlock()
+	return len(fake.writeHeaderArgsForCall)
+}
+
+func (fake *FakeResponseWriter) WriteHeaderCalls(stub func(int)) {
+	fake.writeHeaderMutex.Lock()
+	defer fake.writeHeaderMutex.Unlock()
+	fake.WriteHeaderStub = stub
+}
+
+func (fake *FakeResponseWriter) WriteHeaderArgsForCall(i int) int {
+	fake.writeHeaderMutex.RLock()
+	defer fake.writeHeaderMutex.RUnlock()
+	argsForCall := fake.writeHeaderArgsForCall[i]
+	return argsForCall.arg1
+}
+
+func (fake *FakeResponseWriter) Invocations() map[string][][]interface{} {
+	fake.invocationsMutex.RLock()
+	defer fake.invocationsMutex.RUnlock()
+	fake.headerMutex.RLock()
+	defer fake.headerMutex.RUnlock()
+	fake.writeMutex.RLock()
+	defer fake.writeMutex.RUnlock()
+	fake.writeHeaderMutex.RLock()
+	defer fake.writeHeaderMutex.RUnlock()
+	copiedInvocations := map[string][][]interface{}{}
+	for key, value := range fake.invocations {
+		copiedInvocations[key] = value
+	}
+	return copiedInvocations
+}
+
+func (fake *FakeResponseWriter) recordInvocation(key string, args []interface{}) {
+	fake.invocationsMutex.Lock()
+	defer fake.invocationsMutex.Unlock()
+	if fake.invocations == nil {
+		fake.invocations = map[string][][]interface{}{}
+	}
+	if fake.invocations[key] == nil {
+		fake.invocations[key] = [][]interface{}{}
+	}
+	fake.invocations[key] = append(fake.invocations[key], args)
+}
+
+var _ http.ResponseWriter = new(FakeResponseWriter)
diff --git a/handlers/handlers_suite_test.go b/handlers/handlers_suite_test.go
new file mode 100644
index 00000000..d592ee4e
--- /dev/null
+++ b/handlers/handlers_suite_test.go
@@ -0,0 +1,15 @@
+package handlers_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+)
+
+//go:generate counterfeiter -o fakes/fake_response_writer.go -fake-name FakeResponseWriter net/http.ResponseWriter
+
+func TestHandlers(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "Handlers Suite")
+}
diff --git a/handlers/last_binding_operation_test.go b/handlers/last_binding_operation_test.go
new file mode 100644
index 00000000..5e313981
--- /dev/null
+++ b/handlers/last_binding_operation_test.go
@@ -0,0 +1,139 @@
+package handlers_test
+
+import (
+	"code.cloudfoundry.org/lager"
+	"encoding/json"
+	"fmt"
+	"github.com/gorilla/mux"
+	. "github.com/onsi/ginkgo"
+	. "github.com/onsi/gomega"
+	"github.com/pivotal-cf/brokerapi/domain"
+	"github.com/pivotal-cf/brokerapi/domain/apiresponses"
+	brokerFakes "github.com/pivotal-cf/brokerapi/fakes"
+	"github.com/pivotal-cf/brokerapi/handlers"
+	"github.com/pivotal-cf/brokerapi/handlers/fakes"
+	"github.com/pkg/errors"
+	"net/http"
+	"net/url"
+)
+
+var _ = Describe("LastBindingOperation", func() {
+	var (
+		fakeServiceBroker  *brokerFakes.AutoFakeServiceBroker
+		fakeResponseWriter *fakes.FakeResponseWriter
+		apiHandler         handlers.APIHandler
+
+		instanceID, bindingID        string
+		planID, serviceID, operation string
+	)
+
+	BeforeEach(func() {
+		instanceID = "some-instance-id"
+		bindingID = "some-binding-id"
+		planID = "a-plan"
+		serviceID = "a-service"
+		operation = "a-operation"
+
+		fakeServiceBroker = new(brokerFakes.AutoFakeServiceBroker)
+
+		apiHandler = handlers.NewApiHandler(fakeServiceBroker, lager.NewLogger("test"))
+
+		fakeResponseWriter = new(fakes.FakeResponseWriter)
+		fakeResponseWriter.HeaderReturns(http.Header{})
+	})
+
+	It("responds with OK when broker can retrieve the last binding operation", func() {
+		request := newRequest(instanceID, bindingID, planID, serviceID, operation)
+		expectedLastOperation := domain.LastOperation{
+			State:       domain.Succeeded,
+			Description: "muy bien",
+		}
+
+		fakeServiceBroker.LastBindingOperationReturns(expectedLastOperation, nil)
+
+		apiHandler.LastBindingOperation(fakeResponseWriter, request)
+
+		statusCode := fakeResponseWriter.WriteHeaderArgsForCall(0)
+		Expect(statusCode).To(Equal(http.StatusOK))
+		body := fakeResponseWriter.WriteArgsForCall(0)
+		Expect(body).To(MatchJSON(toJSON(expectedLastOperation)))
+
+		_, actualInstanceID, actualBindingID, actualPollDetails := fakeServiceBroker.LastBindingOperationArgsForCall(0)
+		Expect(actualPollDetails).To(Equal(domain.PollDetails{
+			PlanID:        planID,
+			ServiceID:     serviceID,
+			OperationData: operation,
+		}))
+		Expect(actualInstanceID).To(Equal(instanceID))
+		Expect(actualBindingID).To(Equal(bindingID))
+	})
+
+	It("responds with PreConditionFailed when api version is not supported", func() {
+		request := newRequest(instanceID, bindingID, planID, serviceID, operation)
+		request.Header.Set("X-Broker-API-Version", "2.13")
+
+		apiHandler.LastBindingOperation(fakeResponseWriter, request)
+
+		statusCode := fakeResponseWriter.WriteHeaderArgsForCall(0)
+		Expect(statusCode).To(Equal(http.StatusPreconditionFailed))
+		body := fakeResponseWriter.WriteArgsForCall(0)
+		Expect(body).To(MatchJSON(`{"description":"get binding endpoint only supported starting with OSB version 2.14"}`))
+	})
+
+	It("responds with InternalServerError when last binding operation returns unknown error", func() {
+		request := newRequest(instanceID, bindingID, planID, serviceID, operation)
+
+		fakeServiceBroker.LastBindingOperationReturns(domain.LastOperation{}, errors.New("some error"))
+
+		apiHandler.LastBindingOperation(fakeResponseWriter, request)
+
+		statusCode := fakeResponseWriter.WriteHeaderArgsForCall(0)
+		Expect(statusCode).To(Equal(http.StatusInternalServerError))
+		body := fakeResponseWriter.WriteArgsForCall(0)
+		Expect(body).To(MatchJSON(`{"description":"some error"}`))
+	})
+
+	It("responds appropriately when last binding operation returns a known error", func() {
+		request := newRequest(instanceID, bindingID, planID, serviceID, operation)
+		err := errors.New("some-amazing-error")
+		fakeServiceBroker.LastBindingOperationReturns(
+			domain.LastOperation{},
+			apiresponses.NewFailureResponse(err, http.StatusTeapot, "last-binding-op"),
+		)
+
+		apiHandler.LastBindingOperation(fakeResponseWriter, request)
+
+		statusCode := fakeResponseWriter.WriteHeaderArgsForCall(0)
+		Expect(statusCode).To(Equal(http.StatusTeapot))
+		body := fakeResponseWriter.WriteArgsForCall(0)
+		Expect(body).To(MatchJSON(`{"description":"some-amazing-error"}`))
+	})
+})
+
+func toJSON(operation domain.LastOperation) []byte {
+	d, err := json.Marshal(operation)
+	Expect(err).ToNot(HaveOccurred())
+	return d
+}
+
+func newRequest(instanceID, bindingID, planID, serviceID, operation string) *http.Request {
+	request, err := http.NewRequest(
+		"GET",
+		fmt.Sprintf("https://broker.url/v2/service_instances/%s/service_bindings/%s/last_operation", instanceID, bindingID),
+		nil,
+	)
+	Expect(err).ToNot(HaveOccurred())
+	request.Header.Add("X-Broker-API-Version", "2.14")
+
+	request = mux.SetURLVars(request, map[string]string{
+		"instance_id": instanceID,
+		"binding_id":  bindingID,
+	})
+
+	request.Form = url.Values{}
+	request.Form.Add("plan_id", planID)
+	request.Form.Add("service_id", serviceID)
+	request.Form.Add("operation", operation)
+
+	return request
+}
diff --git a/middlewares/api_version_header.go b/middlewares/api_version_header.go
index 4d72b46f..efe56e28 100644
--- a/middlewares/api_version_header.go
+++ b/middlewares/api_version_header.go
@@ -35,7 +35,6 @@ type ErrorResponse struct {
 }
 
 func (m APIVersionMiddleware) ValidateAPIVersionHdr(next http.Handler) http.Handler {
-
 	return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
 		logger := m.LoggerFactory.Session("version-header-check", lager.Data{})