diff --git a/.travis.yml b/.travis.yml
index 5b4bd3c8b..d0fd06864 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,3 +1,6 @@
+notifications:
+  email: false
+
 language: go
 
 go:
@@ -13,10 +16,13 @@ install:
 
 jobs:
   include:
-    - stage: lint
+    - stage: Lint
       script: make lint
-    - stage: ci
-      script: make ci
+    - stage: Test unit and integration
+      script: make test-unit-coverage
+    - stage: Test e2e
+      script: make test-e2e
+
 cache:
   directories:
   - .ethereumtest
diff --git a/Makefile b/Makefile
index f5b4e0f4f..acc15c704 100644
--- a/Makefile
+++ b/Makefile
@@ -88,10 +88,12 @@ mock-install: ##@other Install mocking tools
 mock: ##@other Regenerate mocks
 	mockgen -source=geth/common/types.go -destination=geth/common/types_mock.go -package=common
 
-test: ##@tests Run unit and integration tests
+test: test-unit-coverage ##@tests Run basic, short tests during development
+
+test-unit: ##@tests Run unit and integration tests
 	build/env.sh go test $(UNIT_TEST_PACKAGES)
 
-test-coverage: ##@tests Run unit and integration tests with covevare
+test-unit-coverage: ##@tests Run unit and integration tests with coverage
 	build/env.sh go test -coverpkg= $(UNIT_TEST_PACKAGES)
 
 test-e2e: ##@tests Run e2e tests
@@ -106,7 +108,7 @@ test-e2e: ##@tests Run e2e tests
 	build/env.sh go test -timeout 10m ./e2e/transactions/...
 	build/env.sh go test -timeout 40m ./cmd/statusd
 
-ci: mock-install mock test-coverage test-e2e ##@tests Run all tests in CI
+ci: lint mock-install mock test-unit test-e2e ##@tests Run all linters and tests at once
 
 clean: ##@other Cleanup
 	rm -fr build/bin/*
diff --git a/cmd/statusd/utils.go b/cmd/statusd/utils.go
index 119ef7ff0..02df5c51e 100644
--- a/cmd/statusd/utils.go
+++ b/cmd/statusd/utils.go
@@ -2,6 +2,7 @@ package main
 
 import "C"
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
@@ -17,6 +18,7 @@ import (
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core"
 	gethparams "github.com/ethereum/go-ethereum/params"
+	"github.com/stretchr/testify/require"
 
 	"github.com/status-im/status-go/geth/account"
 	"github.com/status-im/status-go/geth/common"
@@ -25,7 +27,6 @@ import (
 	"github.com/status-im/status-go/geth/txqueue"
 	"github.com/status-im/status-go/static"
 	. "github.com/status-im/status-go/testing" //nolint: golint
-	"github.com/stretchr/testify/require"
 )
 
 const zeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000"
diff --git a/e2e/accounts/accounts_test.go b/e2e/accounts/accounts_test.go
index 59895c002..de7edb907 100644
--- a/e2e/accounts/accounts_test.go
+++ b/e2e/accounts/accounts_test.go
@@ -137,41 +137,41 @@ func (s *AccountsTestSuite) TestRecoverAccount() {
 	keyStore, err := s.Backend.NodeManager().AccountKeyStore()
 	s.NoError(err)
 
-	// create an account
+	// create an acc
 	address, pubKey, mnemonic, err := s.Backend.AccountManager().CreateAccount(TestConfig.Account1.Password)
 	s.NoError(err)
 	s.T().Logf("Account created: {address: %s, key: %s, mnemonic:%s}", address, pubKey, mnemonic)
 
 	// try recovering using password + mnemonic
 	addressCheck, pubKeyCheck, err := s.Backend.AccountManager().RecoverAccount(TestConfig.Account1.Password, mnemonic)
-	s.NoError(err, "recover account failed")
+	s.NoError(err, "recover acc failed")
 	s.False(address != addressCheck || pubKey != pubKeyCheck, "incorrect accound details recovered")
 
-	// now test recovering, but make sure that account/key file is removed i.e. simulate recovering on a new device
-	account, err := common.ParseAccountString(address)
-	s.NoError(err, "can not get account from address")
+	// now test recovering, but make sure that acc/key file is removed i.e. simulate recovering on a new device
+	acc, err := common.ParseAccountString(address)
+	s.NoError(err, "can not get acc from address")
 
-	account, key, err := keyStore.AccountDecryptedKey(account, TestConfig.Account1.Password)
-	s.NoError(err, "can not obtain decrypted account key")
+	acc, key, err := keyStore.AccountDecryptedKey(acc, TestConfig.Account1.Password)
+	s.NoError(err, "can not obtain decrypted acc key")
 	extChild2String := key.ExtendedKey.String()
 
-	s.NoError(keyStore.Delete(account, TestConfig.Account1.Password), "cannot remove account")
+	s.NoError(keyStore.Delete(acc, TestConfig.Account1.Password), "cannot remove acc")
 
 	addressCheck, pubKeyCheck, err = s.Backend.AccountManager().RecoverAccount(TestConfig.Account1.Password, mnemonic)
-	s.NoError(err, "recover account failed (for non-cached account)")
+	s.NoError(err, "recover acc failed (for non-cached acc)")
 	s.False(address != addressCheck || pubKey != pubKeyCheck,
-		"incorrect account details recovered (for non-cached account)")
+		"incorrect acc details recovered (for non-cached acc)")
 
 	// make sure that extended key exists and is imported ok too
-	_, key, err = keyStore.AccountDecryptedKey(account, TestConfig.Account1.Password)
+	_, key, err = keyStore.AccountDecryptedKey(acc, TestConfig.Account1.Password)
 	s.NoError(err)
 	s.Equal(extChild2String, key.ExtendedKey.String(), "CKD#2 key mismatch")
 
 	// make sure that calling import several times, just returns from cache (no error is expected)
 	addressCheck, pubKeyCheck, err = s.Backend.AccountManager().RecoverAccount(TestConfig.Account1.Password, mnemonic)
-	s.NoError(err, "recover account failed (for non-cached account)")
+	s.NoError(err, "recover acc failed (for non-cached acc)")
 	s.False(address != addressCheck || pubKey != pubKeyCheck,
-		"incorrect account details recovered (for non-cached account)")
+		"incorrect acc details recovered (for non-cached acc)")
 
 	// time to login with recovered data
 	whisperService := s.WhisperService()
diff --git a/e2e/transactions/transactions_test.go b/e2e/transactions/transactions_test.go
index df9f826af..f0dd1a76e 100644
--- a/e2e/transactions/transactions_test.go
+++ b/e2e/transactions/transactions_test.go
@@ -96,12 +96,12 @@ func (s *TransactionsTestSuite) TestCallRPCSendTransactionUpstream() {
 
 	var txHash gethcommon.Hash
 	signal.SetDefaultNodeNotificationHandler(func(rawSignal string) {
-		var signal signal.Envelope
-		err := json.Unmarshal([]byte(rawSignal), &signal)
+		var signalEnvelope signal.Envelope
+		err := json.Unmarshal([]byte(rawSignal), &signalEnvelope)
 		s.NoError(err)
 
-		if signal.Type == txqueue.EventTransactionQueued {
-			event := signal.Event.(map[string]interface{})
+		if signalEnvelope.Type == txqueue.EventTransactionQueued {
+			event := signalEnvelope.Event.(map[string]interface{})
 			txID := event["id"].(string)
 
 			// Complete with a wrong passphrase.
diff --git a/geth/jail/jail.go b/geth/jail/jail.go
index 0dc627274..0caac65db 100644
--- a/geth/jail/jail.go
+++ b/geth/jail/jail.go
@@ -54,9 +54,9 @@ func (jail *Jail) NewCell(chatID string) (common.JailCell, error) {
 		return nil, ErrInvalidJail
 	}
 
-	vm := otto.New()
+	cellVM := otto.New()
 
-	cell, err := newCell(chatID, vm)
+	cell, err := newCell(chatID, cellVM)
 	if err != nil {
 		return nil, err
 	}