diff --git a/auth/auth_test.go b/auth/auth_test.go
index e1de803..ecb90d1 100644
--- a/auth/auth_test.go
+++ b/auth/auth_test.go
@@ -1,12 +1,10 @@
 package auth
 
 import (
-	"errors"
 	"fmt"
 	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
-	"reflect"
 	"testing"
 
 	deis "github.com/deis/controller-sdk-go"
@@ -247,17 +245,16 @@ func TestDeleteUserApp(t *testing.T) {
 	server := httptest.NewServer(&handler)
 	defer server.Close()
 
-	deis, err := deis.New(false, server.URL, "abc", "")
+	d, err := deis.New(false, server.URL, "abc", "")
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = Delete(deis, "admin")
+	err = Delete(d, "admin")
 	// should be a 409 Conflict
 
-	expected := errors.New("409 Conflict")
-	if reflect.DeepEqual(err, expected) == false {
-		t.Errorf("got '%s' but expected '%s'", err, expected)
+	if err != deis.ErrConflict {
+		t.Errorf("got '%s' but expected '%s'", err, deis.ErrConflict)
 	}
 }
 
diff --git a/errors.go b/errors.go
new file mode 100644
index 0000000..f56b218
--- /dev/null
+++ b/errors.go
@@ -0,0 +1,208 @@
+package deis
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"strings"
+)
+
+const (
+	// formatErrUnknown is used to create an dynamic error if no error matches
+	formatErrUnknown = "Unknown Error (%d): %s"
+	// fieldReqMsg is API error stating a field is required.
+	fieldReqMsg       = "This field is required."
+	invalidUserMsg    = "Enter a valid username. This value may contain only letters, numbers and @/./+/-/_ characters."
+	failedLoginMsg    = "Unable to log in with provided credentials."
+	invalidAppNameMsg = "App name can only contain a-z (lowercase), 0-9 and hypens"
+	invalidNameMsg    = "Can only contain a-z (lowercase), 0-9 and hypens"
+	invalidCertMsg    = "Could not load certificate"
+	invalidPodMsg     = "does not exist in application"
+	invalidDomainMsg  = "Hostname does not look valid."
+	invalidVersionMsg = "version cannot be below 0"
+	invalidKeyMsg     = "Key contains invalid base64 chars"
+)
+
+var (
+	// ErrNotFound is returned when the server returns a 404.
+	ErrNotFound = errors.New("Not Found")
+	// ErrServerError is returned when the server returns a 500.
+	ErrServerError = errors.New("Internal Server Error")
+	// ErrMethodNotAllowed is thrown when using a unsupposrted method.
+	// This should not come up unless there in an bug in the SDK.
+	ErrMethodNotAllowed = errors.New("Method Not Allowed")
+	// ErrInvalidUsername is returned when the user specifies an invalid or missing username.
+	ErrInvalidUsername = errors.New(invalidUserMsg)
+	// ErrMissingPassword is returned when a password is not sent with the request.
+	ErrMissingPassword = errors.New("A Password is required")
+	// ErrLogin is returned when the api cannot login fails with provided username and password
+	ErrLogin = errors.New(failedLoginMsg)
+	// ErrUnauthorized is given when the API returns a 401.
+	ErrUnauthorized = errors.New("Unauthorized: Missing or Invalid Token")
+	// ErrInvalidAppName is returned when the user specifies an invalid app name.
+	ErrInvalidAppName = errors.New(invalidAppNameMsg)
+	// ErrConflict is returned when the API returns a 409.
+	ErrConflict = errors.New("This action could not be completed due to a conflict.")
+	// ErrForbidden is returned when the API returns a 403.
+	ErrForbidden = errors.New("You do not have permission to perform this action.")
+	// ErrMissingKey is returned when a key is not sent with the request.
+	ErrMissingKey = errors.New("A key is required")
+	// ErrInvalidName is returned when a name is invalid or missing.
+	ErrInvalidName = errors.New(invalidNameMsg)
+	// ErrInvalidCertificate is returned when a certififate is missing or invalid
+	ErrInvalidCertificate = errors.New(invalidCertMsg)
+	// ErrPodNotFound is returned when a pod type is not Found
+	ErrPodNotFound = errors.New("Pod not found in application")
+	// ErrInvalidDomain is returned when a domain is missing or invalid
+	ErrInvalidDomain = errors.New(invalidDomainMsg)
+	// ErrInvalidImage is returned when a image is missing or invalid
+	ErrInvalidImage = errors.New("The given image is invalid")
+	// ErrInvalidVersion is returned when a version is invalid
+	ErrInvalidVersion = errors.New("The given version is invalid")
+	// ErrMissingID is returned when a ID is missing
+	ErrMissingID = errors.New("An id is required")
+)
+
+func checkForErrors(res *http.Response) error {
+	if res.StatusCode >= 200 && res.StatusCode < 400 {
+		return nil
+	}
+
+	// Fix json.Decoder bug in <go1.7
+	defer func() {
+		io.Copy(ioutil.Discard, res.Body)
+		res.Body.Close()
+	}()
+
+	switch res.StatusCode {
+	case 400:
+		bodyMap := make(map[string]interface{})
+		if err := json.NewDecoder(res.Body).Decode(&bodyMap); err != nil {
+			return unknownError(res.StatusCode, err)
+		}
+
+		if scanResponse(bodyMap, "username", []string{fieldReqMsg, invalidUserMsg}, true) {
+			return ErrInvalidUsername
+		}
+
+		if scanResponse(bodyMap, "password", []string{fieldReqMsg}, true) {
+			return ErrMissingPassword
+		}
+
+		if scanResponse(bodyMap, "non_field_errors", []string{failedLoginMsg}, true) {
+			return ErrLogin
+		}
+
+		if scanResponse(bodyMap, "id", []string{invalidAppNameMsg}, true) {
+			return ErrInvalidAppName
+		}
+
+		if scanResponse(bodyMap, "key", []string{fieldReqMsg}, true) {
+			return ErrMissingKey
+		}
+
+		if scanResponse(bodyMap, "public", []string{fieldReqMsg, invalidKeyMsg}, true) {
+			return ErrMissingKey
+		}
+
+		if scanResponse(bodyMap, "certificate", []string{fieldReqMsg, invalidCertMsg}, false) {
+			return ErrInvalidCertificate
+		}
+
+		if scanResponse(bodyMap, "name", []string{fieldReqMsg, invalidNameMsg}, true) {
+			return ErrInvalidName
+		}
+
+		if scanResponse(bodyMap, "domain", []string{invalidDomainMsg}, true) {
+			return ErrInvalidDomain
+		}
+
+		if scanResponse(bodyMap, "image", []string{fieldReqMsg}, true) {
+			return ErrInvalidImage
+		}
+
+		if scanResponse(bodyMap, "id", []string{fieldReqMsg}, true) {
+			return ErrMissingID
+		}
+
+		if v, ok := bodyMap["detail"].(string); ok {
+			if strings.Contains(v, invalidPodMsg) {
+				return ErrPodNotFound
+			}
+			if strings.Contains(v, invalidVersionMsg) {
+				return ErrInvalidVersion
+			}
+		}
+
+		return unknownError(res.StatusCode, bodyMap)
+	case 401:
+		return ErrUnauthorized
+	case 403:
+		return ErrForbidden
+	case 404:
+		return ErrNotFound
+	case 405:
+		return ErrMethodNotAllowed
+	case 409:
+		return ErrConflict
+	case 500:
+		return ErrServerError
+	default:
+		out, err := ioutil.ReadAll(res.Body)
+		if err != nil {
+			return unknownError(res.StatusCode, err)
+		}
+		return unknownError(res.StatusCode, out)
+	}
+}
+
+func arrayContents(m map[string]interface{}, field string) []string {
+	if v, ok := m[field]; ok {
+		if a, ok := v.([]interface{}); ok {
+			sa := []string{}
+
+			for _, i := range a {
+				if s, ok := i.(string); ok {
+					sa = append(sa, s)
+				}
+			}
+			return sa
+		}
+	}
+
+	return []string{}
+}
+
+func arrayContains(search string, completeMatch bool, array []string) bool {
+	for _, element := range array {
+		if completeMatch {
+			if element == search {
+				return true
+			}
+		} else {
+			if strings.Contains(element, search) {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+func unknownError(sc int, k interface{}) error {
+	return fmt.Errorf(formatErrUnknown, sc, k)
+}
+
+func scanResponse(
+	body map[string]interface{}, field string, errMsgs []string, completeMatch bool) bool {
+	for _, msg := range errMsgs {
+		if arrayContains(msg, completeMatch, arrayContents(body, field)) {
+			return true
+		}
+	}
+
+	return false
+}
diff --git a/errors_test.go b/errors_test.go
new file mode 100644
index 0000000..55c39e6
--- /dev/null
+++ b/errors_test.go
@@ -0,0 +1,234 @@
+package deis
+
+import (
+	"errors"
+	"io"
+	"net/http"
+	"testing"
+)
+
+const failureMessage = "Expected error '%v', Got '%v'"
+
+type mockReadCloser struct {
+	msg    string
+	closed bool
+}
+
+func (m *mockReadCloser) Close() error {
+	m.closed = true
+	return nil
+}
+
+func (m *mockReadCloser) Read(msg []byte) (int, error) {
+	if m.closed == true {
+		return 0, errors.New("You can't read on a closed ReadCloser")
+	}
+
+	if m.msg == "" {
+		return 0, io.EOF
+	}
+
+	for i, b := range []byte(m.msg) {
+		msg[i] = b
+	}
+	len := len(m.msg)
+	m.msg = ""
+	return len, nil
+}
+
+func readCloser(msg string) *mockReadCloser {
+	return &mockReadCloser{msg: msg}
+}
+
+type errorTest struct {
+	expected error
+	res      *http.Response
+}
+
+func TestErrors(t *testing.T) {
+	tests := []errorTest{
+		errorTest{
+			res: &http.Response{
+				StatusCode: 200,
+				Body:       readCloser(""),
+			},
+			expected: nil,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 201,
+				Body:       readCloser(""),
+			},
+			expected: nil,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"username":["This field is required."]}`),
+			},
+			expected: ErrInvalidUsername,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"username":["Enter a valid username. This value may contain only letters, numbers and @/./+/-/_ characters."]}`),
+			},
+			expected: ErrInvalidUsername,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"password":["This field is required."]}`),
+			},
+			expected: ErrMissingPassword,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"non_field_errors":["Unable to log in with provided credentials."]}`),
+			},
+			expected: ErrLogin,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"id":["App name can only contain a-z (lowercase), 0-9 and hypens","Enter a valid \"slug\" consisting of letters, numbers, underscores or hyphens."]}`),
+			},
+			expected: ErrInvalidAppName,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"certificate": ["This field is required."]}`),
+			},
+			expected: ErrInvalidCertificate,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"certificate":["Could not load certificate: [('PEM routines', 'PEM_read_bio', 'no start line')]"]}`),
+			},
+			expected: ErrInvalidCertificate,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"key": ["This field is required."]}`),
+			},
+			expected: ErrMissingKey,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"public":["Key contains invalid base64 chars"]}`),
+			},
+			expected: ErrMissingKey,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"public":["This field is required."]}`),
+			},
+			expected: ErrMissingKey,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"name": ["This field is required."]}`),
+			},
+			expected: ErrInvalidName,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"name":["Can only contain a-z (lowercase), 0-9 and hypens"]}`),
+			},
+			expected: ErrInvalidName,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"detail":"Container type foo does not exist in application"}`),
+			},
+			expected: ErrPodNotFound,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"domain":["Hostname does not look valid."]}`),
+			},
+			expected: ErrInvalidDomain,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"image":["This field is required."]}`),
+			},
+			expected: ErrInvalidImage,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"detail":"version cannot be below 0"}`),
+			},
+			expected: ErrInvalidVersion,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 400,
+				Body:       readCloser(`{"id":["This field is required."]}`),
+			},
+			expected: ErrMissingID,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 401,
+				Body:       readCloser(""),
+			},
+			expected: ErrUnauthorized,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 403,
+				Body:       readCloser(""),
+			},
+			expected: ErrForbidden,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 404,
+				Body:       readCloser(""),
+			},
+			expected: ErrNotFound,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 405,
+				Body:       readCloser(""),
+			},
+			expected: ErrMethodNotAllowed,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 409,
+				Body:       readCloser(""),
+			},
+			expected: ErrConflict,
+		},
+		errorTest{
+			res: &http.Response{
+				StatusCode: 500,
+				Body:       readCloser(""),
+			},
+			expected: ErrServerError,
+		},
+	}
+
+	for _, check := range tests {
+		actual := checkForErrors(check.res)
+
+		if actual != check.expected {
+			t.Errorf(failureMessage, check.expected, actual)
+		}
+	}
+}
diff --git a/http.go b/http.go
index 6f1765c..292a696 100644
--- a/http.go
+++ b/http.go
@@ -4,7 +4,6 @@ import (
 	"bytes"
 	"crypto/tls"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"io/ioutil"
 	"net/http"
@@ -97,22 +96,6 @@ func (c *Client) LimitedRequest(path string, results int) (string, int, error) {
 	return string(out), int(r["count"].(float64)), nil
 }
 
-func checkForErrors(res *http.Response) error {
-
-	// If response is not an error, return nil.
-	if res.StatusCode > 199 && res.StatusCode < 400 {
-		return nil
-	}
-
-	// TEMPORARY: Close body because methods won't close it (for now) because
-	// they can't tell the difference between an HTTP error and a bad status code
-	// (which has a body to close)
-	res.Body.Close()
-
-	//TODO: Implement better error system!
-	return errors.New(res.Status)
-}
-
 // CheckConnection checks that the user is connected to a network and the URL points to a valid controller.
 func (c *Client) CheckConnection() error {
 	errorMessage := `%s does not appear to be a valid Deis controller.
diff --git a/http_test.go b/http_test.go
index 69feaa5..3e0b28a 100644
--- a/http_test.go
+++ b/http_test.go
@@ -168,28 +168,6 @@ func TestBasicRequest(t *testing.T) {
 	}
 }
 
-func TestCheckErrorsReturnsNil(t *testing.T) {
-	t.Parallel()
-
-	responses := []http.Response{
-		{
-			StatusCode: http.StatusOK,
-		},
-		{
-			StatusCode: http.StatusCreated,
-		},
-		{
-			StatusCode: http.StatusNoContent,
-		},
-	}
-
-	for _, res := range responses {
-		if err := checkForErrors(&res); err != nil {
-			t.Fatal(err)
-		}
-	}
-}
-
 func TestLimitedRequest(t *testing.T) {
 	t.Parallel()