diff --git a/api.go b/api.go
index e6fd817..859452e 100644
--- a/api.go
+++ b/api.go
@@ -182,7 +182,7 @@
 	}
 }
 
-func sendDeployments(w http.ResponseWriter, dataDeps []dataDeployment, eTag string) {
+func sendDeployments(w http.ResponseWriter, dataDeps []DataDeployment, eTag string) {
 
 	var apiDeps apiDeploymentResponse
 
diff --git a/api_test.go b/api_test.go
index 8bc93e6..be29bd1 100644
--- a/api_test.go
+++ b/api_test.go
@@ -309,7 +309,7 @@
 	tx, err := getDB().Begin()
 	Expect(err).ShouldNot(HaveOccurred())
 
-	dep := dataDeployment{
+	dep := DataDeployment{
 		ID: deploymentID,
 		BundleConfigID: deploymentID,
 		ApidClusterID: deploymentID,
@@ -328,7 +328,7 @@
 		LocalBundleURI: "x",
 	}
 
-	err = insertDeployment(tx, dep)
+	err = InsertDeployment(tx, dep)
 	Expect(err).ShouldNot(HaveOccurred())
 
 	err = tx.Commit()
diff --git a/bundle.go b/bundle.go
index 311534c..4762165 100644
--- a/bundle.go
+++ b/bundle.go
@@ -25,7 +25,7 @@
 	backOffMultiplier = 10 * time.Second
 )
 
-func downloadBundle(dep dataDeployment) error {
+func downloadBundle(dep DataDeployment) error {
 
 	log.Debugf("starting bundle download process: %s", dep.BundleURI)
 
@@ -77,7 +77,7 @@
 	return nil
 }
 
-func getBundleFile(dep dataDeployment) string {
+func getBundleFile(dep DataDeployment) string {
 
 	// the content of the URI is unfortunately not guaranteed not to change, so I can't just use dep.BundleURI
 	// unfortunately, this also means that a bundle cache isn't especially relevant
diff --git a/cmd/apidGatewayDeploy/main.go b/cmd/apidGatewayDeploy/main.go
index 5b162d4..10e1989 100644
--- a/cmd/apidGatewayDeploy/main.go
+++ b/cmd/apidGatewayDeploy/main.go
@@ -6,54 +6,60 @@
 	"github.com/30x/apid/factory"
 	_ "github.com/30x/apidGatewayDeploy"
 	"io/ioutil"
-	"github.com/apigee-labs/transicator/common"
 	"github.com/30x/apidGatewayDeploy"
 	"os"
 )
 
 func main() {
-	manifestFlag := flag.String("manifest", "", "file path to a manifest yaml file")
+	bundleFlag := flag.String("bundle", "", "file path to a bundle file (for testing)")
+	configFlag := flag.String("config", "", "file path to a bundle config file (for testing)")
 	flag.Parse()
-	manifestFile := *manifestFlag
+	bundleFile := *bundleFlag
+	configFile := *configFlag
 
-	// initialize apid using default services
 	apid.Initialize(factory.DefaultServicesFactory())
 
 	log := apid.Log()
 	log.Debug("initializing...")
 
-	config := apid.Config()
+	configService := apid.Config()
 
-	// if manifest is specified, start with only the manifest using a temp dir
-	var manifest []byte
-	if manifestFile != "" {
-		var err error
-		manifest, err = ioutil.ReadFile(manifestFile)
-		if err != nil {
-			log.Errorf("ERROR: Unable to read manifest at %s", manifestFile)
-			return
-		}
-
-		log.Printf("Running in temp dir with manifest: %s", manifestFile)
+	// if bundle is specified, start in a temp dir for testing
+	var bundleConfig string
+	if bundleFile != "" {
+		log.Printf("Running in temp dir with bundle file: %s", bundleFile)
 		tmpDir, err := ioutil.TempDir("", "apidGatewayDeploy")
 		if err != nil {
 			log.Panicf("ERROR: Unable to create temp dir", err)
 		}
 		defer os.RemoveAll(tmpDir)
-		config.Set("data_path", tmpDir)
-		config.Set("gatewaydeploy_bundle_dir", tmpDir)
+
+		configService.Set("data_path", tmpDir)
+		configService.Set("gatewaydeploy_bundle_dir", tmpDir)
+
+		if configFile != "" {
+			bundleConfigBytes, err := ioutil.ReadFile(configFile)
+			if err != nil {
+				log.Errorf("ERROR: Unable to read bundle config file at %s", configFile)
+				return
+
+			}
+			bundleConfig = string(bundleConfigBytes)
+		}
 	}
 
-	// this will call all initialization functions on all registered plugins
 	apid.InitializePlugins()
 
-	if manifest != nil {
-		insertTestRecord(manifest)
+	if bundleFile != "" {
+		err := insertTestDeployment(bundleFile, bundleConfig)
+		if err != nil {
+			log.Fatal(err)
+		}
 	}
 
 	// print the base url to the console
 	basePath := "/deployments"
-	port := config.GetString("api_port")
+	port := configService.GetString("api_port")
 	log.Print()
 	log.Printf("API is at: http://localhost:%s%s", port, basePath)
 	log.Print()
@@ -64,19 +70,51 @@
 	log.Fatalf("Error. Is something already running on port %d? %s", port, err)
 }
 
-func insertTestRecord(manifest []byte) {
+func insertTestDeployment(bundleFile, bundleConfig string) error {
 
-	row := common.Row{}
-	row["id"] = &common.ColumnVal{Value: "deploymentID"}
-	row["manifest_body"] = &common.ColumnVal{Value: string(manifest)}
+	deploymentID := "testDeployment"
 
-	var event = common.Snapshot{}
-	event.Tables = []common.Table{
-		{
-			Name: apiGatewayDeploy.MANIFEST_TABLE,
-			Rows: []common.Row{row},
-		},
+	dep := apiGatewayDeploy.DataDeployment{
+		ID: deploymentID,
+		BundleConfigID: deploymentID,
+		ApidClusterID: deploymentID,
+		DataScopeID: deploymentID,
+		BundleConfigJSON: bundleConfig,
+		ConfigJSON: "",
+		Status: "",
+		Created: "",
+		CreatedBy: "",
+		Updated: "",
+		UpdatedBy: "",
+		BundleName: deploymentID,
+		BundleURI: bundleFile,
+		BundleChecksum: "",
+		BundleChecksumType: "",
+		LocalBundleURI: bundleFile,
 	}
 
-	apid.Events().Emit(apiGatewayDeploy.APIGEE_SYNC_EVENT, &event)
-}
+	log := apid.Log()
+
+	db, err := apid.Data().DB()
+	if err != nil {
+		return err
+	}
+
+	tx, err := db.Begin()
+	if err != nil {
+		return err
+	}
+
+	err = apiGatewayDeploy.InsertDeployment(tx, dep)
+	if err != nil {
+		log.Error("Unable to insert deployment")
+		return err
+	}
+
+	err = tx.Commit()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
\ No newline at end of file
diff --git a/data.go b/data.go
index c9aa520..d0f6785 100644
--- a/data.go
+++ b/data.go
@@ -12,7 +12,7 @@
 	dbMux    sync.RWMutex
 )
 
-type dataDeployment struct {
+type DataDeployment struct {
 	ID                string
 	BundleConfigID    string
 	ApidClusterID     string
@@ -119,7 +119,7 @@
 	return eTag, err
 }
 
-func insertDeployment(tx *sql.Tx, dep dataDeployment) error {
+func InsertDeployment(tx *sql.Tx, dep DataDeployment) error {
 
 	log.Debugf("insertDeployment: %s", dep.ID)
 
@@ -175,7 +175,7 @@
 }
 
 // getReadyDeployments() returns array of deployments that are ready to deploy
-func getReadyDeployments() (deployments []dataDeployment, err error) {
+func getReadyDeployments() (deployments []DataDeployment, err error) {
 
 	db := getDB()
 	rows, err := db.Query(`
@@ -196,7 +196,7 @@
 	defer rows.Close()
 
 	for rows.Next() {
-		dep := dataDeployment{}
+		dep := DataDeployment{}
 		rows.Scan(&dep.ID, &dep.BundleConfigID, &dep.ApidClusterID, &dep.DataScopeID,
 			&dep.BundleConfigJSON, &dep.ConfigJSON, &dep.Status, &dep.Created,
 			&dep.CreatedBy, &dep.Updated, &dep.UpdatedBy, &dep.BundleName,
@@ -208,40 +208,6 @@
 	return
 }
 
-// for testing
-func getAllDeploymentRecords() (deployments []dataDeployment, err error) {
-
-	db := getDB()
-	rows, err := db.Query(`
-	SELECT id, bundle_config_id, apid_cluster_id, data_scope_id,
-		bundle_config_json, config_json, status, created,
-		created_by, updated, updated_by, bundle_name,
-		bundle_uri, local_bundle_uri
-	FROM deployments
-	`)
-	if err != nil {
-		if err == sql.ErrNoRows{
-			return deployments, nil
-		}
-		log.Errorf("Error querying deployments: %v", err)
-		return
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		dep := dataDeployment{}
-		rows.Scan(&dep.ID, &dep.BundleConfigID, &dep.ApidClusterID, &dep.DataScopeID,
-			&dep.BundleConfigJSON, &dep.ConfigJSON, &dep.Status, &dep.Created,
-			&dep.CreatedBy, &dep.Updated, &dep.UpdatedBy, &dep.BundleName,
-			&dep.BundleURI, &dep.LocalBundleURI,
-		)
-		deployments = append(deployments, dep)
-	}
-
-	return
-}
-
-// todo: is this a sufficient level of tracking?
 func setDeploymentResults(results apiDeploymentResults) error {
 
 	log.Debugf("setDeploymentResults: %v", results)
diff --git a/listener.go b/listener.go
index 655ea97..246e525 100644
--- a/listener.go
+++ b/listener.go
@@ -124,7 +124,7 @@
 
 func addDeployment(tx *sql.Tx, row common.Row) (err error) {
 
-	d := dataDeployment{}
+	d := DataDeployment{}
 	err = row.Get("id", &d.ID)
 	if err != nil {
 		return
@@ -182,7 +182,7 @@
 	d.BundleChecksumType = bc.ChecksumType
 	d.BundleChecksum = bc.Checksum
 
-	err = insertDeployment(tx, d)
+	err = InsertDeployment(tx, d)
 	if err != nil {
 		return
 	}
diff --git a/listener_test.go b/listener_test.go
index 1bde3aa..ec4b7f2 100644
--- a/listener_test.go
+++ b/listener_test.go
@@ -134,11 +134,11 @@
 
 			tx, err := getDB().Begin()
 			Expect(err).ShouldNot(HaveOccurred())
-			dep := dataDeployment{
+			dep := DataDeployment{
 				ID: deploymentID,
 				LocalBundleURI: "whatever",
 			}
-			err = insertDeployment(tx, dep)
+			err = InsertDeployment(tx, dep)
 			Expect(err).ShouldNot(HaveOccurred())
 			err = tx.Commit()
 			Expect(err).ShouldNot(HaveOccurred())