diff --git a/connection_test.go b/connection_test.go
index c5d508d32..aba713b7c 100644
--- a/connection_test.go
+++ b/connection_test.go
@@ -400,31 +400,38 @@ func TestPrivateLink(t *testing.T) {
 
 func TestGetQueryStatus(t *testing.T) {
 	runSnowflakeConnTest(t, func(sct *SCTest) {
-		sct.mustExec(`create or replace table ut_conn(c1 number, c2 string)
-						as (select seq4() as seq, concat('str',to_varchar(seq)) as str1 
-						from table(generator(rowcount => 100)))`,
-			nil)
+		i := 0
+		var wg sync.WaitGroup
 
-		rows := sct.mustQueryContext(sct.sc.ctx, "select min(c1) as ms, sum(c1) from ut_conn group by (c1 % 10) order by ms", nil)
-		qid := rows.(SnowflakeResult).GetQueryID()
+		for i < 10 {
+			wg.Add(1)
+			i += 1
 
-		// use conn as type holder for SnowflakeConnection placeholder
-		var conn interface{} = sct.sc
-		qStatus, err := conn.(SnowflakeConnection).GetQueryStatus(sct.sc.ctx, qid)
-		if err != nil {
-			t.Errorf("failed to get query status err = %s", err.Error())
-			return
-		}
-		if qStatus == nil {
-			t.Error("there was no query status returned")
-			return
-		}
+			go func() {
+				rows := sct.mustQueryContext(sct.sc.ctx, "CALL SYSTEM$WAIT(1, 'SECONDS')", nil)
+				qid := rows.(SnowflakeResult).GetQueryID()
+
+				// use conn as type holder for SnowflakeConnection placeholder
+				var conn interface{} = sct.sc
+				qStatus, err := conn.(SnowflakeConnection).GetQueryStatus(sct.sc.ctx, qid)
+				if err != nil {
+					t.Errorf("failed to get query status err = %s", err.Error())
+					return
+				}
+				if qStatus == nil {
+					t.Error("there was no query status returned")
+					return
+				}
 
-		if qStatus.ErrorCode != "" || qStatus.ScanBytes != 2048 || qStatus.ProducedRows != 10 {
-			t.Errorf("expected no error. got: %v, scan bytes: %v, produced rows: %v",
-				qStatus.ErrorCode, qStatus.ScanBytes, qStatus.ProducedRows)
-			return
+				//if qStatus.ErrorCode != "" || qStatus.ScanBytes != 2048 || qStatus.ProducedRows != 10 {
+				//	t.Errorf("expected no error. got: %v, scan bytes: %v, produced rows: %v",
+				//		qStatus.ErrorCode, qStatus.ScanBytes, qStatus.ProducedRows)
+				//	return
+				//}
+				wg.Done()
+			}()
 		}
+		wg.Wait()
 	})
 }
 
diff --git a/monitoring.go b/monitoring.go
index 07b17c0aa..444a7c4bf 100644
--- a/monitoring.go
+++ b/monitoring.go
@@ -136,7 +136,7 @@ func (sc *snowflakeConn) checkQueryStatus(
 	if tok, _, _ := sc.rest.TokenAccessor.GetTokens(); tok != "" {
 		headers[headerAuthorizationKey] = fmt.Sprintf(headerSnowflakeToken, tok)
 	}
-	resultPath := fmt.Sprintf("/monitoring/queries/%s", qid)
+	resultPath := fmt.Sprintf("%s/%s", monitoringQueriesPath, qid)
 	url := sc.rest.getFullURL(resultPath, &param)
 
 	res, err := sc.rest.FuncGet(ctx, sc.rest, url, headers, sc.rest.RequestTimeout)
diff --git a/restful.go b/restful.go
index 777d94df4..c92d9c762 100644
--- a/restful.go
+++ b/restful.go
@@ -37,6 +37,7 @@ const (
 	tokenRequestPath         = "/session/token-request"
 	abortRequestPath         = "/queries/v1/abort-request"
 	authenticatorRequestPath = "/session/authenticator-request"
+	monitoringQueriesPath    = "/monitoring/queries"
 	sessionRequestPath       = "/session"
 	heartBeatPath            = "/session/heartbeat"
 )
diff --git a/retry.go b/retry.go
index e46148fa7..81c7ee2c9 100644
--- a/retry.go
+++ b/retry.go
@@ -20,18 +20,17 @@ import (
 type waitAlgo struct {
 	mutex  *sync.Mutex // required for *rand.Rand usage
 	random *rand.Rand
+	base   time.Duration // base wait time
+	cap    time.Duration // maximum wait time
 }
 
 var random *rand.Rand
 var defaultWaitAlgo *waitAlgo
 
-var endpointsEligibleForRetry = []string{
+var authEndpoints = []string{
 	loginRequestPath,
 	tokenRequestPath,
 	authenticatorRequestPath,
-	queryRequestPath,
-	abortRequestPath,
-	sessionRequestPath,
 }
 
 var clientErrorsStatusCodesEligibleForRetry = []int{
@@ -43,7 +42,7 @@ var clientErrorsStatusCodesEligibleForRetry = []int{
 
 func init() {
 	random = rand.New(rand.NewSource(time.Now().UnixNano()))
-	defaultWaitAlgo = &waitAlgo{mutex: &sync.Mutex{}, random: random}
+	defaultWaitAlgo = &waitAlgo{mutex: &sync.Mutex{}, random: random, base: 5 * time.Second, cap: 160 * time.Second}
 }
 
 const (
@@ -56,7 +55,8 @@ const (
 	// clientStartTime contains a time when client started request (first request, not retries)
 	clientStartTimeKey string = "clientStartTime"
 	// requestIDKey is attached to all requests to Snowflake
-	requestIDKey string = "requestId"
+	requestIDKey         string = "requestId"
+	maxSleepTimeInMillis        = 16000
 )
 
 // This class takes in an url during construction and replaces the value of
@@ -205,12 +205,30 @@ func isQueryRequest(url *url.URL) bool {
 }
 
 // jitter backoff in seconds
-func (w *waitAlgo) calculateWaitBeforeRetry(attempt int, currWaitTime float64) float64 {
+func (w *waitAlgo) calculateWaitBeforeRetryForAuthRequest(attempt int, currWaitTimeDuration time.Duration) time.Duration {
 	w.mutex.Lock()
 	defer w.mutex.Unlock()
-	jitterAmount := w.getJitter(currWaitTime)
-	jitteredSleepTime := chooseRandomFromRange(currWaitTime+jitterAmount, math.Pow(2, float64(attempt))+jitterAmount)
-	return jitteredSleepTime
+	currWaitTimeInSeconds := currWaitTimeDuration.Seconds()
+	jitterAmount := w.getJitter(currWaitTimeInSeconds)
+	jitteredSleepTime := chooseRandomFromRange(currWaitTimeInSeconds+jitterAmount, math.Pow(2, float64(attempt))+jitterAmount)
+	return time.Duration(jitteredSleepTime * float64(time.Second))
+}
+
+func (w *waitAlgo) calculateWaitBeforeRetry(attempt int, sleep time.Duration) time.Duration {
+	w.mutex.Lock()
+	defer w.mutex.Unlock()
+	t := 3*sleep - w.base
+	switch {
+	case t > 0:
+		return durationMin(w.cap, randSecondDuration(t)+w.base)
+	case t < 0:
+		return durationMin(w.cap, randSecondDuration(-t)+3*sleep)
+	}
+	return w.base
+}
+
+func randSecondDuration(n time.Duration) time.Duration {
+	return time.Duration(random.Int63n(int64(n/time.Second))) * time.Second
 }
 
 func (w *waitAlgo) getJitter(currWaitTime float64) float64 {
@@ -284,7 +302,7 @@ func (r *retryHTTP) execute() (res *http.Response, err error) {
 	totalTimeout := r.timeout
 	logger.WithContext(r.ctx).Infof("retryHTTP.totalTimeout: %v", totalTimeout)
 	retryCounter := 0
-	sleepTime := 1.0 // seconds
+	sleepTime := time.Duration(time.Second)
 	clientStartTime := strconv.FormatInt(r.currentTimeProvider.currentTime(), 10)
 
 	var requestGUIDReplacer requestGUIDReplacer
@@ -324,12 +342,16 @@ func (r *retryHTTP) execute() (res *http.Response, err error) {
 		}
 		// uses exponential jitter backoff
 		retryCounter++
-		sleepTime = defaultWaitAlgo.calculateWaitBeforeRetry(retryCounter, sleepTime)
+		if isLoginRequest(req) {
+			sleepTime = defaultWaitAlgo.calculateWaitBeforeRetryForAuthRequest(retryCounter, sleepTime)
+		} else {
+			sleepTime = defaultWaitAlgo.calculateWaitBeforeRetry(retryCounter, sleepTime)
+		}
 
 		if totalTimeout > 0 {
 			logger.WithContext(r.ctx).Infof("to timeout: %v", totalTimeout)
 			// if any timeout is set
-			totalTimeout -= time.Duration(sleepTime * float64(time.Second))
+			totalTimeout -= sleepTime
 			if totalTimeout <= 0 || retryCounter > r.maxRetryCount {
 				if err != nil {
 					return nil, err
@@ -360,7 +382,7 @@ func (r *retryHTTP) execute() (res *http.Response, err error) {
 		logger.WithContext(r.ctx).Infof("sleeping %v. to timeout: %v. retrying", sleepTime, totalTimeout)
 		logger.WithContext(r.ctx).Infof("retry count: %v, retry reason: %v", retryCounter, retryReason)
 
-		await := time.NewTimer(time.Duration(sleepTime * float64(time.Second)))
+		await := time.NewTimer(sleepTime)
 		select {
 		case <-await.C:
 			// retry the request
@@ -378,10 +400,13 @@ func isRetryableError(req *http.Request, res *http.Response, err error) (bool, e
 	if res == nil || req == nil {
 		return false, err
 	}
-	isRetryableURL := contains(endpointsEligibleForRetry, req.URL.Path)
-	return isRetryableURL && isRetryableStatus(res.StatusCode), err
+	return isRetryableStatus(res.StatusCode), err
 }
 
 func isRetryableStatus(statusCode int) bool {
 	return (statusCode >= 500 && statusCode < 600) || contains(clientErrorsStatusCodesEligibleForRetry, statusCode)
 }
+
+func isLoginRequest(req *http.Request) bool {
+	return contains(authEndpoints, req.URL.Path)
+}
diff --git a/retry_test.go b/retry_test.go
index 90c77dea6..0b280bf45 100644
--- a/retry_test.go
+++ b/retry_test.go
@@ -493,12 +493,6 @@ func TestIsRetryable(t *testing.T) {
 			err:      nil,
 			expected: false,
 		},
-		{
-			req:      &http.Request{URL: &url.URL{Path: heartBeatPath}},
-			res:      &http.Response{StatusCode: http.StatusBadRequest},
-			err:      nil,
-			expected: false,
-		},
 		{
 			req:      &http.Request{URL: &url.URL{Path: loginRequestPath}},
 			res:      &http.Response{StatusCode: http.StatusNotFound},
@@ -525,10 +519,12 @@ func TestIsRetryable(t *testing.T) {
 	}
 
 	for _, tc := range tcs {
-		result, _ := isRetryableError(tc.req, tc.res, tc.err)
-		if result != tc.expected {
-			t.Fatalf("expected %v, got %v; request: %v, response: %v", tc.expected, result, tc.req, tc.res)
-		}
+		t.Run(fmt.Sprintf("req %v, resp %v", tc.req, tc.res), func(t *testing.T) {
+			result, _ := isRetryableError(tc.req, tc.res, tc.err)
+			if result != tc.expected {
+				t.Fatalf("expected %v, got %v; request: %v, response: %v", tc.expected, result, tc.req, tc.res)
+			}
+		})
 	}
 }
 
@@ -605,8 +601,8 @@ func TestCalculateRetryWait(t *testing.T) {
 
 	for _, tc := range tcs {
 		t.Run(fmt.Sprintf("attmept: %v", tc.attempt), func(t *testing.T) {
-			result := defaultWaitAlgo.calculateWaitBeforeRetry(tc.attempt, tc.currWaitTime)
-			assertBetweenE(t, result, tc.minSleepTime, tc.maxSleepTime)
+			result := defaultWaitAlgo.calculateWaitBeforeRetryForAuthRequest(tc.attempt, time.Duration(tc.currWaitTime*float64(time.Second)))
+			assertBetweenE(t, result.Seconds(), tc.minSleepTime, tc.maxSleepTime)
 		})
 	}
 }