diff --git a/README.md b/README.md
index 168daed..9691d3a 100644
--- a/README.md
+++ b/README.md
@@ -23,9 +23,13 @@
 Duration between deleting a deployment and deleting it's bundles on disk. 
 Default: "1s"
 
-#### gatewaydeploy_bundle_download_timeout
-Duration before bundle download marks deployment as failed (will continue retries regardless). 
-Default: "1m"
+#### gatewaydeploy_download_connection_timeout
+Duration before a bundle download connection terminates  
+Default: "5m"
+
+#### gatewaydeploy_deployment_timeout
+Duration before bundle download marks deployment as failed (will continue download retries regardless). 
+Default: "10m"
 
 #### gatewaydeploy_bundle_dir
 Relative location from local_storage_path in which to store local bundle files.
diff --git a/apidGatewayDeploy_suite_test.go b/apidGatewayDeploy_suite_test.go
index ad253e0..ccb41b2 100644
--- a/apidGatewayDeploy_suite_test.go
+++ b/apidGatewayDeploy_suite_test.go
@@ -50,7 +50,7 @@
 	debounceDuration = time.Millisecond
 	bundleCleanupDelay = time.Millisecond
 	bundleRetryDelay = 10 * time.Millisecond
-	bundleDownloadTimeout = 50 * time.Millisecond
+	markDeploymentFailedAfter = 50 * time.Millisecond
 	concurrentDownloads = 1
 	downloadQueueSize = 1
 
@@ -76,7 +76,7 @@
 			return
 		}
 		if vars["id"] == "longfail" {
-			time.Sleep(bundleDownloadTimeout + (250 * time.Millisecond))
+			time.Sleep(markDeploymentFailedAfter + (250 * time.Millisecond))
 		}
 		w.Write([]byte("/bundles/" + vars["id"]))
 
diff --git a/bundle.go b/bundle.go
index 1163946..1105606 100644
--- a/bundle.go
+++ b/bundle.go
@@ -18,10 +18,11 @@
 )
 
 var (
-	bundleRetryDelay      = time.Second
-	bundleDownloadTimeout = 10 * time.Minute
-	downloadQueue         = make(chan *DownloadRequest, downloadQueueSize)
-	workerQueue           = make(chan chan *DownloadRequest, concurrentDownloads)
+	markDeploymentFailedAfter time.Duration
+	bundleDownloadConnTimeout time.Duration
+	bundleRetryDelay          = time.Second
+	downloadQueue             = make(chan *DownloadRequest, downloadQueueSize)
+	workerQueue               = make(chan chan *DownloadRequest, concurrentDownloads)
 )
 
 // simple doubling back-off
@@ -55,13 +56,13 @@
 
 	retryIn := bundleRetryDelay
 	maxBackOff := 5 * time.Minute
-	timeoutAfter := time.Now().Add(bundleDownloadTimeout)
+	markFailedAt := time.Now().Add(markDeploymentFailedAfter)
 	req := &DownloadRequest{
 		dep:          dep,
 		hashWriter:   hashWriter,
 		bundleFile:   getBundleFile(dep),
 		backoffFunc:  createBackoff(retryIn, maxBackOff),
-		timeoutAfter: timeoutAfter,
+		markFailedAt: markFailedAt,
 	}
 	downloadQueue <- req
 }
@@ -71,7 +72,7 @@
 	hashWriter   hash.Hash
 	bundleFile   string
 	backoffFunc  func()
-	timeoutAfter time.Time
+	markFailedAt time.Time
 }
 
 func (r *DownloadRequest) downloadBundle() {
@@ -122,9 +123,9 @@
 
 func (r *DownloadRequest) checkTimeout() {
 
-	if !r.timeoutAfter.IsZero() {
-		if time.Now().After(r.timeoutAfter) {
-			r.timeoutAfter = time.Time{}
+	if !r.markFailedAt.IsZero() {
+		if time.Now().After(r.markFailedAt) {
+			r.markFailedAt = time.Time{}
 			log.Debugf("bundle download timeout. marking deployment %s failed. will keep retrying: %s",
 				r.dep.ID, r.dep.BundleURI)
 			setDeploymentResults(apiDeploymentResults{
@@ -209,7 +210,10 @@
 	}
 
 	// GET the contents at uriString
-	res, err := http.Get(uriString)
+	client := http.Client{
+		Timeout: bundleDownloadConnTimeout,
+	}
+	res, err := client.Get(uriString)
 	if err != nil {
 		return nil, err
 	}
diff --git a/bundle_test.go b/bundle_test.go
index 796be9a..84989ea 100644
--- a/bundle_test.go
+++ b/bundle_test.go
@@ -16,18 +16,73 @@
 
 	Context("download", func() {
 
-		It("should timeout, mark status as failed, then finish", func() {
+		It("should timeout connection and retry", func() {
+			defer func() {
+				bundleDownloadConnTimeout = time.Second
+			}()
+			bundleDownloadConnTimeout = 100 * time.Millisecond
+			firstTime := true
+			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				if firstTime {
+					firstTime = false
+					time.Sleep(1 * time.Second)
+					w.WriteHeader(500)
+				} else {
+					//proceed <- true
+					w.Write([]byte("/bundles/longfail"))
+				}
+			}))
+			defer ts.Close()
+
+			uri, err := url.Parse(ts.URL)
+			Expect(err).ShouldNot(HaveOccurred())
+			uri.Path = "/bundles/longfail"
+
+			tx, err := getDB().Begin()
+			Expect(err).ShouldNot(HaveOccurred())
+
+			deploymentID := "bundle_download_fail"
+			dep := DataDeployment{
+				ID:                 deploymentID,
+				DataScopeID:        deploymentID,
+				BundleURI:          uri.String(),
+				BundleChecksum:     testGetChecksum("crc-32", uri.String()),
+				BundleChecksumType: "crc-32",
+			}
+
+			err = InsertDeployment(tx, dep)
+			Expect(err).ShouldNot(HaveOccurred())
+
+			err = tx.Commit()
+			Expect(err).ShouldNot(HaveOccurred())
+
+			queueDownloadRequest(dep)
+
+			var listener = make(chan string)
+			addSubscriber <- listener
+			<-listener
+
+			getReadyDeployments()
+			deployments, err := getReadyDeployments()
+			Expect(err).ShouldNot(HaveOccurred())
+
+			Expect(len(deployments)).To(Equal(1))
+			d := deployments[0]
+			Expect(d.ID).To(Equal(deploymentID))
+		})
+
+		It("should timeout deployment, mark status as failed, then finish", func() {
 
 			proceed := make(chan bool)
 			failedOnce := false
 			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 				if failedOnce {
 					proceed <- true
-					time.Sleep(bundleDownloadTimeout)
+					time.Sleep(markDeploymentFailedAfter)
 					w.Write([]byte("/bundles/longfail"))
 				} else {
 					failedOnce = true
-					time.Sleep(bundleDownloadTimeout)
+					time.Sleep(markDeploymentFailedAfter)
 					w.WriteHeader(500)
 				}
 			}))
@@ -234,7 +289,7 @@
 			queueDownloadRequest(dep)
 
 			// give download time to finish
-			time.Sleep(bundleDownloadTimeout + (100 * time.Millisecond))
+			time.Sleep(markDeploymentFailedAfter + (100 * time.Millisecond))
 
 			deployments, err := getReadyDeployments()
 			Expect(err).ShouldNot(HaveOccurred())
diff --git a/init.go b/init.go
index f507357..ff39a3e 100644
--- a/init.go
+++ b/init.go
@@ -14,7 +14,8 @@
 	configBundleDirKey          = "gatewaydeploy_bundle_dir"
 	configDebounceDuration      = "gatewaydeploy_debounce_duration"
 	configBundleCleanupDelay    = "gatewaydeploy_bundle_cleanup_delay"
-	configBundleDownloadTimeout = "gatewaydeploy_bundle_download_timeout"
+	configMarkDeployFailedAfter = "gatewaydeploy_deployment_timeout"
+	configDownloadConnTimeout   = "gatewaydeploy_download_connection_timeout"
 	configApiServerBaseURI      = "apigeesync_proxy_server_base"
 	configApidInstanceID        = "apigeesync_apid_instance_id"
 	configApidClusterID         = "apigeesync_cluster_id"
@@ -69,7 +70,8 @@
 	config.SetDefault(configBundleDirKey, "bundles")
 	config.SetDefault(configDebounceDuration, time.Second)
 	config.SetDefault(configBundleCleanupDelay, time.Minute)
-	config.SetDefault(configBundleDownloadTimeout, 5*time.Minute)
+	config.SetDefault(configMarkDeployFailedAfter, 10*time.Minute)
+	config.SetDefault(configDownloadConnTimeout, 5*time.Minute)
 	config.SetDefault(configConcurrentDownloads, 15)
 	config.SetDefault(configDownloadQueueSize, 2000)
 
@@ -83,9 +85,14 @@
 		return pluginData, fmt.Errorf("%s must be a positive duration", configBundleCleanupDelay)
 	}
 
-	bundleDownloadTimeout = config.GetDuration(configBundleDownloadTimeout)
-	if bundleDownloadTimeout < time.Millisecond {
-		return pluginData, fmt.Errorf("%s must be a positive duration", configBundleDownloadTimeout)
+	markDeploymentFailedAfter = config.GetDuration(configMarkDeployFailedAfter)
+	if markDeploymentFailedAfter < time.Millisecond {
+		return pluginData, fmt.Errorf("%s must be a positive duration", configMarkDeployFailedAfter)
+	}
+
+	bundleDownloadConnTimeout = config.GetDuration(configDownloadConnTimeout)
+	if bundleDownloadConnTimeout < time.Millisecond {
+		return pluginData, fmt.Errorf("%s must be a positive duration", configDownloadConnTimeout)
 	}
 
 	data = services.Data()
diff --git a/listener.go b/listener.go
index 0f5c493..938b9d2 100644
--- a/listener.go
+++ b/listener.go
@@ -119,6 +119,7 @@
 			if err != nil {
 				log.Panicf("unable to query database for unready deployments: %v", err)
 			}
+			log.Debugf("Queuing %d deployments for bundle download", len(deployments))
 			for _, dep := range deployments {
 				queueDownloadRequest(dep)
 			}
diff --git a/listener_test.go b/listener_test.go
index dbee310..40c9ce4 100644
--- a/listener_test.go
+++ b/listener_test.go
@@ -66,6 +66,73 @@
 
 			close(done)
 		})
+
+		It("should set DB and process unready on startup event", func(done Done) {
+
+			deploymentID := "startup_test"
+
+			uri, err := url.Parse(testServer.URL)
+			Expect(err).ShouldNot(HaveOccurred())
+
+			uri.Path = "/bundles/1"
+			bundleUri := uri.String()
+			bundle := bundleConfigJson{
+				Name:         uri.Path,
+				URI:          bundleUri,
+				ChecksumType: "crc-32",
+			}
+			bundle.Checksum = testGetChecksum(bundle.ChecksumType, bundleUri)
+
+			dep := DataDeployment{
+				ID:                 deploymentID,
+				DataScopeID:        deploymentID,
+				BundleURI:          bundle.URI,
+				BundleChecksum:     bundle.Checksum,
+				BundleChecksumType: bundle.ChecksumType,
+			}
+
+			// init without info == startup on existing DB
+			var snapshot = common.Snapshot{
+				SnapshotInfo: "test",
+				Tables:       []common.Table{},
+			}
+
+			db, err := data.DBVersion(snapshot.SnapshotInfo)
+			if err != nil {
+				log.Panicf("Unable to access database: %v", err)
+			}
+
+			err = InitDB(db)
+			if err != nil {
+				log.Panicf("Unable to initialize database: %v", err)
+			}
+
+			tx, err := db.Begin()
+			Expect(err).ShouldNot(HaveOccurred())
+
+			err = InsertDeployment(tx, dep)
+			Expect(err).ShouldNot(HaveOccurred())
+
+			err = tx.Commit()
+			Expect(err).ShouldNot(HaveOccurred())
+
+			var listener = make(chan string)
+			addSubscriber <- listener
+
+			apid.Events().Emit(APIGEE_SYNC_EVENT, &snapshot)
+
+			id := <-listener
+			Expect(id).To(Equal(deploymentID))
+
+			deployments, err := getReadyDeployments()
+			Expect(err).ShouldNot(HaveOccurred())
+
+			Expect(len(deployments)).To(Equal(1))
+			d := deployments[0]
+
+			Expect(d.ID).To(Equal(deploymentID))
+			close(done)
+		})
 	})
 
 	Context("ApigeeSync change event", func() {