diff --git a/notebooks/scenarios/bigquery/00-start-and-configure-server-and-admins.ipynb b/notebooks/scenarios/bigquery/00-start-and-configure-server-and-admins.ipynb
index 0454f649d9a..213c4c6d405 100644
--- a/notebooks/scenarios/bigquery/00-start-and-configure-server-and-admins.ipynb
+++ b/notebooks/scenarios/bigquery/00-start-and-configure-server-and-admins.ipynb
@@ -212,13 +212,6 @@
    "source": [
     "server.land()"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
diff --git a/notebooks/scenarios/bigquery/01-setup-datasite.ipynb b/notebooks/scenarios/bigquery/01-setup-datasite.ipynb
index 23eeb437d86..51e4efb58c7 100644
--- a/notebooks/scenarios/bigquery/01-setup-datasite.ipynb
+++ b/notebooks/scenarios/bigquery/01-setup-datasite.ipynb
@@ -476,13 +476,6 @@
    "source": [
     "server.land()"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
diff --git a/notebooks/scenarios/bigquery/011-users-emails-passwords.ipynb b/notebooks/scenarios/bigquery/011-users-emails-passwords.ipynb
index 5f8f9ad0793..45e6e10d847 100644
--- a/notebooks/scenarios/bigquery/011-users-emails-passwords.ipynb
+++ b/notebooks/scenarios/bigquery/011-users-emails-passwords.ipynb
@@ -383,14 +383,6 @@
    "source": [
     "server.land()"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "29",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
diff --git a/notebooks/scenarios/bigquery/03-ds-submit-request.ipynb b/notebooks/scenarios/bigquery/021-create-jobs.ipynb
similarity index 50%
rename from notebooks/scenarios/bigquery/03-ds-submit-request.ipynb
rename to notebooks/scenarios/bigquery/021-create-jobs.ipynb
index 5040a41c0f1..9d718e8c24e 100644
--- a/notebooks/scenarios/bigquery/03-ds-submit-request.ipynb
+++ b/notebooks/scenarios/bigquery/021-create-jobs.ipynb
@@ -3,10 +3,13 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "0",
    "metadata": {},
    "outputs": [],
    "source": [
+    "# stdlib\n",
     "# import os\n",
+    "\n",
     "# os.environ[\"ORCHESTRA_DEPLOYMENT_TYPE\"] = \"remote\"\n",
     "# os.environ[\"DEV_MODE\"] = \"True\"\n",
     "# os.environ[\"TEST_EXTERNAL_REGISTRY\"] = \"k3d-registry.localhost:5800\""
@@ -15,17 +18,45 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# use_live_bigquery = False\n",
+    "# os.environ[\"TEST_BIGQUERY_APIS_LIVE\"] = str(use_live_bigquery)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2",
    "metadata": {},
    "outputs": [],
    "source": [
+    "# stdlib\n",
+    "import os\n",
+    "\n",
+    "environment = os.environ.get(\"ORCHESTRA_DEPLOYMENT_TYPE\", \"python\")\n",
+    "environment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# third party\n",
+    "\n",
     "# syft absolute\n",
-    "import syft as sy\n",
-    "from syft import test_settings"
+    "import syft as sy"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "4",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -35,6 +66,7 @@
     "from helpers import SMTPTestServer\n",
     "\n",
     "email_server = EmailServer()\n",
+    "email_server.reset_emails()\n",
     "smtp_server = SMTPTestServer(email_server)\n",
     "smtp_server.start()"
    ]
@@ -42,6 +74,18 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "SERVER_PORT = \"8080\"\n",
+    "SERVER_URL = f\"http://localhost:{SERVER_PORT}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -49,8 +93,8 @@
     "    name=\"bigquery-high\",\n",
     "    dev_mode=True,\n",
     "    server_side_type=\"high\",\n",
-    "    port=\"8080\",\n",
-    "    n_consumers=1,  # How many workers to be spawned\n",
+    "    port=SERVER_PORT,\n",
+    "    n_consumers=4,  # How many workers to be spawned\n",
     "    create_producer=True,  # Can produce more workers\n",
     ")"
    ]
@@ -58,6 +102,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "7",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -70,6 +115,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "8",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -80,6 +126,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "9",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -87,224 +134,259 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "ds1 = users[1]\n",
-    "ds1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
+   "id": "10",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "ds1.client.custom_api.api_endpoints()"
+    "# Create jobs"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "11",
    "metadata": {},
    "outputs": [],
    "source": [
-    "ds1.client.api.services.bigquery.test_query"
+    "# third party\n",
+    "from job_helpers import TestJob\n",
+    "from job_helpers import create_jobs\n",
+    "from job_helpers import extract_code_path"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
+   "id": "12",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "dataset_1 = test_settings.get(\"dataset_1\", default=\"dataset_1\")\n",
-    "dataset_2 = test_settings.get(\"dataset_2\", default=\"dataset_2\")\n",
-    "table_1 = test_settings.get(\"table_1\", default=\"table_1\")\n",
-    "table_2 = test_settings.get(\"table_2\", default=\"table_2\")\n",
-    "table_2_col_id = test_settings.get(\"table_2_col_id\", default=\"table_id\")\n",
-    "table_2_col_score = test_settings.get(\"table_2_col_score\", default=\"colname\")\n",
-    "query_limit_size = test_settings.get(\"query_limit_size\", default=10000)"
+    "# Test queries"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "13",
    "metadata": {},
    "outputs": [],
    "source": [
-    "FUNC_NAME = \"popular\"\n",
-    "QUERY = f\"SELECT {table_2_col_id}, AVG({table_2_col_score}) AS average_score \\\n",
-    "    FROM {dataset_2}.{table_2} \\\n",
-    "    GROUP BY {table_2_col_id} \\\n",
-    "    LIMIT 10000\"\n",
+    "# maybe we should assign one of each first, and then randomly generate the rest\n",
+    "n_per_user = 2\n",
     "\n",
-    "result = ds1.client.api.services.bigquery.test_query(sql_query=QUERY)"
+    "jobs = create_jobs(users, n_per_user=n_per_user)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "14",
    "metadata": {},
    "outputs": [],
    "source": [
-    "assert len(result) == 10000"
+    "jobs"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "15",
    "metadata": {},
    "outputs": [],
    "source": [
-    "res1 = ds1.client.api.services.bigquery.submit_query(func_name=FUNC_NAME, query=QUERY)\n",
-    "res1"
+    "# third party\n",
+    "from job_helpers import save_jobs"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "16",
    "metadata": {},
    "outputs": [],
    "source": [
-    "def extract_code_path(response):\n",
-    "    # stdlib\n",
-    "    import re\n",
-    "\n",
-    "    pattern = r\"client\\.code\\.(\\w+)\\(\\)\"\n",
-    "    match = re.search(pattern, str(response))\n",
-    "    if match:\n",
-    "        extracted_code = match.group(1)\n",
-    "        return extracted_code\n",
-    "    return None"
+    "print(f\"num jobs: {len(jobs)}\")\n",
+    "num_should_submit = 0\n",
+    "for job in jobs:\n",
+    "    print(\n",
+    "        f\"Job type: {job.job_type}, should succeed: {job.should_succeed}, should submit: {job.should_submit}\"\n",
+    "    )\n",
+    "    if job.should_submit:\n",
+    "        num_should_submit += 1"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "17",
    "metadata": {},
    "outputs": [],
    "source": [
-    "ds1.client.refresh()"
+    "assert len(jobs) == len(users) * n_per_user\n",
+    "assert all(isinstance(j, TestJob) for j in jobs)\n",
+    "assert all(job.client is not None for job in jobs)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "18",
    "metadata": {},
    "outputs": [],
    "source": [
-    "func_name = extract_code_path(res1)\n",
-    "print(func_name)"
+    "save_jobs(jobs)"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
+   "id": "19",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "assert \"popular\" in func_name"
+    "# Submit jobs\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "20",
    "metadata": {},
    "outputs": [],
    "source": [
-    "api_method = getattr(ds1.client.code, func_name, None)\n",
-    "api_method"
+    "admin_emails_before = len(email_server.get_emails_for_user(\"admin@bigquery.org\"))\n",
+    "print(\"admin emails before\", admin_emails_before)\n",
+    "admin_emails_before"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "21",
    "metadata": {},
    "outputs": [],
    "source": [
-    "with sy.raises(\n",
-    "    sy.SyftException(public_message=\"*Your code is waiting for approval*\"), show=True\n",
-    "):\n",
-    "    result = api_method()"
+    "# stdlib\n",
+    "\n",
+    "responses = []\n",
+    "\n",
+    "for job in jobs:\n",
+    "    client = job.client\n",
+    "\n",
+    "    if not job.should_submit:\n",
+    "        # Submitting should throw error (eg func_name invalid syntax)\n",
+    "        with sy.raises(sy.SyftException):\n",
+    "            response = client.api.services.bigquery.submit_query(\n",
+    "                func_name=job.func_name, query=job.query\n",
+    "            )\n",
+    "        responses.append(None)\n",
+    "    else:\n",
+    "        response = client.api.services.bigquery.submit_query(\n",
+    "            func_name=job.func_name, query=job.query\n",
+    "        )\n",
+    "        job.code_path = extract_code_path(response)\n",
+    "        responses.append(response)\n",
+    "\n",
+    "    # time.sleep(1)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "22",
    "metadata": {},
    "outputs": [],
    "source": [
-    "FUNC_NAME = \"large_sample\"\n",
-    "LARGE_SAMPLE_QUERY = f\"SELECT * FROM {dataset_2}.{table_2} LIMIT {query_limit_size}\""
+    "for job in jobs:\n",
+    "    print(\n",
+    "        f\"Job {job.func_name:.20} is submitted, {job.should_submit}, should be submitted {job.is_submitted}\"\n",
+    "    )\n",
+    "\n",
+    "assert all(job.is_submitted == job.should_submit for job in jobs)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "23",
    "metadata": {},
    "outputs": [],
    "source": [
-    "res2 = ds1.client.api.services.bigquery.submit_query(\n",
-    "    func_name=FUNC_NAME, query=LARGE_SAMPLE_QUERY\n",
-    ")"
+    "save_jobs(jobs)"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": null,
+   "cell_type": "markdown",
+   "id": "24",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "func_name = extract_code_path(res2)\n",
-    "print(func_name)"
+    "## Test: cannot execute"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "25",
    "metadata": {},
    "outputs": [],
    "source": [
-    "assert \"large_sample\" in func_name"
+    "submitted_jobs = [job for job in jobs if job.should_submit]\n",
+    "\n",
+    "assert len(submitted_jobs)  # failsafe for next tests"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "26",
    "metadata": {},
    "outputs": [],
    "source": [
-    "api_method_2 = getattr(ds1.client.code, func_name, None)\n",
-    "api_method_2"
+    "# Blocking\n",
+    "\n",
+    "for job in submitted_jobs:\n",
+    "    execute_code_fn = getattr(job.client.code, job.code_path)\n",
+    "    with sy.raises(\n",
+    "        sy.SyftException(public_message=\"*Your code is waiting for approval*\")\n",
+    "    ):\n",
+    "        result = execute_code_fn()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "27",
    "metadata": {},
    "outputs": [],
    "source": [
-    "with sy.raises(\n",
-    "    sy.SyftException(public_message=\"*Your code is waiting for approval*\"), show=True\n",
-    "):\n",
-    "    result = api_method_2()"
+    "# Nonblocking\n",
+    "\n",
+    "# syft absolute\n",
+    "from syft.service.job.job_stash import JobStatus\n",
+    "\n",
+    "for job in submitted_jobs:\n",
+    "    execute_code_fn = getattr(job.client.code, job.code_path)\n",
+    "    result_job = execute_code_fn(blocking=False)\n",
+    "    result_job.wait()\n",
+    "    assert isinstance(result_job.result, sy.SyftError)\n",
+    "    assert result_job.status == JobStatus.ERRORED\n",
+    "    # time.sleep(1)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "28",
    "metadata": {},
    "outputs": [],
    "source": [
-    "assert len(email_server.get_emails_for_user(user_email=\"admin@bigquery.org\")) >= 3"
+    "admin_emails_after = len(email_server.get_emails_for_user(\"admin@bigquery.org\"))\n",
+    "print(\"admin emails after\", admin_emails_after)\n",
+    "assert admin_emails_after >= admin_emails_before + num_should_submit\n",
+    "# assert len(users_emails) > after_number_of_emails\n",
+    "# assert len(users_emails) == after_number_of_emails + 1"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "29",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -314,6 +396,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "30",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -323,6 +406,7 @@
   {
    "cell_type": "code",
    "execution_count": null,
+   "id": "31",
    "metadata": {},
    "outputs": [],
    "source": []
@@ -348,5 +432,5 @@
   }
  },
  "nbformat": 4,
- "nbformat_minor": 4
+ "nbformat_minor": 5
 }
diff --git a/notebooks/scenarios/bigquery/04-do-review-requests.ipynb b/notebooks/scenarios/bigquery/04-do-review-requests.ipynb
index f2874807a1b..9af349607d1 100644
--- a/notebooks/scenarios/bigquery/04-do-review-requests.ipynb
+++ b/notebooks/scenarios/bigquery/04-do-review-requests.ipynb
@@ -34,9 +34,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "# stdlib\n",
+    "import random\n",
+    "\n",
     "# syft absolute\n",
     "import syft as sy\n",
-    "from syft import test_settings\n",
     "from syft.service.job.job_stash import Job"
    ]
   },
@@ -74,87 +76,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "request = [\n",
-    "    r for r in high_client.requests if r.code.service_func_name == \"large_sample\"\n",
-    "][0]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "request"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "job = request.code(blocking=False)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "job"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "assert isinstance(job, Job)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "query_limit_size = test_settings.get(\"query_limit_size\", default=10000)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "result = job.wait()\n",
-    "\n",
-    "assert len(result) == query_limit_size"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "users_emails = email_server.get_emails_for_user(request.requesting_user_email)\n",
-    "number_of_emails = len(users_emails)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# manually deposit\n",
-    "job_info = job.info(result=True)\n",
-    "response = request.deposit_result(job_info, approve=True)\n",
-    "assert isinstance(response, Job)"
+    "# third party\n",
+    "from helpers import load_users\n",
+    "from job_helpers import load_jobs\n",
+    "from job_helpers import save_jobs"
    ]
   },
   {
@@ -163,10 +88,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "users_emails = email_server.get_emails_for_user(request.requesting_user_email)\n",
-    "after_number_of_emails = len(users_emails)\n",
-    "assert after_number_of_emails > number_of_emails\n",
-    "# assert after_number_of_emails == number_of_emails + 1 # we should only send 1 email"
+    "users = load_users(high_client)"
    ]
   },
   {
@@ -175,9 +97,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "request = [\n",
-    "    r for r in high_client.requests if r.code.service_func_name.startswith(\"popular\")\n",
-    "][0]"
+    "jobs = load_jobs(users, high_client)"
    ]
   },
   {
@@ -186,7 +106,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "request"
+    "all_requests = high_client.requests"
    ]
   },
   {
@@ -195,7 +115,15 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "request.code"
+    "def get_request_for_job(requests, job):\n",
+    "    job_requests = [\n",
+    "        r for r in all_requests if r.code.service_func_name == job.func_name\n",
+    "    ]\n",
+    "    if len(job_requests) == 1:\n",
+    "        return job_requests[0]\n",
+    "    if len(job_requests) > 1:\n",
+    "        raise Exception(f\"Multiple of the same job: {job} in requests: {requests}\")\n",
+    "    return None"
    ]
   },
   {
@@ -204,7 +132,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "assert \"pending\" in str(request.code.status).lower()"
+    "submitted_jobs = [job for job in jobs if job.is_submitted]"
    ]
   },
   {
@@ -213,7 +141,17 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "assert \"popular\" in request.code.service_func_name"
+    "def approve_by_running(request):\n",
+    "    job = request.code(blocking=False)\n",
+    "    result = job.wait()\n",
+    "    print(\"got result of type\", type(result), \"bool\", bool(result))\n",
+    "    # got result of type <class 'syft.service.action.pandas.PandasDataFrameObject'> bool False\n",
+    "    # assert result won't work unless we know what type is coming back\n",
+    "    job_info = job.info(result=True)\n",
+    "    # need force when running multiple times\n",
+    "    # todo check and dont run if its already done\n",
+    "    response = request.deposit_result(job_info, approve=True, force=True)\n",
+    "    return response"
    ]
   },
   {
@@ -222,8 +160,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# drink a can of approve classic 🥤\n",
-    "request.approve()"
+    "# TODO we should record whether it was approved or deposited\n",
+    "# and test doing both in either order as there might be a bug when\n",
+    "# force overwriting\n",
+    "# also changing deny to approve and back again"
    ]
   },
   {
@@ -232,9 +172,34 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "users_emails = email_server.get_emails_for_user(request.requesting_user_email)\n",
-    "assert len(users_emails) > after_number_of_emails\n",
-    "assert len(users_emails) == after_number_of_emails + 1"
+    "for job in submitted_jobs:\n",
+    "    request = get_request_for_job(all_requests, job)\n",
+    "    choice = None\n",
+    "    number_of_emails = len(\n",
+    "        email_server.get_emails_for_user(request.requesting_user_email)\n",
+    "    )\n",
+    "    if job.should_succeed:\n",
+    "        if random.randrange(2):\n",
+    "            choice = \"approved with deposit_result\"\n",
+    "            response = approve_by_running(request)\n",
+    "            assert isinstance(response, Job)\n",
+    "        else:\n",
+    "            choice = \"approved\"\n",
+    "            response = request.approve()\n",
+    "            assert isinstance(response, sy.SyftSuccess)\n",
+    "    else:\n",
+    "        choice = \"denied\"\n",
+    "        response = request.deny(\n",
+    "            reason=f\"Your request {job.func_name} looks wrong, try again.\"\n",
+    "        )\n",
+    "        assert isinstance(response, sy.SyftSuccess)\n",
+    "\n",
+    "    after_users_emails = len(\n",
+    "        email_server.get_emails_for_user(request.requesting_user_email)\n",
+    "    )\n",
+    "    # assert after_users_emails > number_of_emails\n",
+    "    job.admin_reviewed = True\n",
+    "    print(f\"Job {job.func_name} should succeed: {job.should_succeed} and was {choice}\")"
    ]
   },
   {
@@ -243,9 +208,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# job_info = job.info(result=True)\n",
-    "# # response = request.deposit_result(job_info, approve=True)\n",
-    "# # assert isinstance(response, Job)"
+    "save_jobs(jobs)"
    ]
   },
   {
diff --git a/notebooks/scenarios/bigquery/05-ds-get-results.ipynb b/notebooks/scenarios/bigquery/05-ds-get-results.ipynb
index 456967e64f4..f9f7a36ae84 100644
--- a/notebooks/scenarios/bigquery/05-ds-get-results.ipynb
+++ b/notebooks/scenarios/bigquery/05-ds-get-results.ipynb
@@ -35,17 +35,7 @@
    "outputs": [],
    "source": [
     "# syft absolute\n",
-    "import syft as sy\n",
-    "from syft import test_settings"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "query_limit_size = test_settings.get(\"query_limit_size\", default=10000)"
+    "import syft as sy"
    ]
   },
   {
@@ -83,7 +73,9 @@
    "outputs": [],
    "source": [
     "# third party\n",
-    "from helpers import load_users"
+    "from helpers import load_users\n",
+    "from job_helpers import load_jobs\n",
+    "from job_helpers import save_jobs"
    ]
   },
   {
@@ -101,8 +93,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "ds1 = users[1]\n",
-    "ds1"
+    "jobs = load_jobs(users, high_client)"
    ]
   },
   {
@@ -111,8 +102,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "job = ds1.client.code.large_sample(blocking=False)\n",
-    "job"
+    "# submitted_jobs = [job for job in jobs if job.is_submitted]\n",
+    "reviewed_jobs = [job for job in jobs if job.admin_reviewed]\n",
+    "len(reviewed_jobs)"
    ]
   },
   {
@@ -121,7 +113,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "result = job.wait().get()"
+    "# TODO: test jobs that were never approved\n",
+    "# they seem to give weird errors like\n",
+    "# \"You uploaded an ActionObject that is not yet in the blob storage\""
    ]
   },
   {
@@ -130,50 +124,42 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(\"> got result\", type(result))\n",
-    "if hasattr(result, \"__len__\"):\n",
-    "    assert len(result) == query_limit_size\n",
-    "    print(\"> result len\", len(result))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "job2 = ds1.client.code.popular(blocking=False)\n",
-    "job2"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "result2 = job2.wait().get()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# stdlib\n",
-    "import sys\n",
+    "for job in reviewed_jobs:\n",
+    "    print(f\"> Checking job: {job.job_type} {job.func_name} for user {job.user_email}\")\n",
+    "    api_method = job.code_method\n",
     "\n",
-    "sys.stdout.write(f\"> got result2 {type(result2)}\\n\")\n",
-    "if hasattr(result2, \"__len__\"):\n",
-    "    sys.stdout.write(f\"> result2 len {len(result2)}\\n\")"
+    "    if job.should_succeed:\n",
+    "        print(\"Expecting job to succeed\")\n",
+    "        j = api_method(blocking=False)\n",
+    "        result = j.wait().get()\n",
+    "        print(\n",
+    "            \"> Got result of type\",\n",
+    "            type(result),\n",
+    "            \"expecting limit\",\n",
+    "            job.settings[\"limit\"],\n",
+    "        )\n",
+    "        if hasattr(result, \"__len__\"):\n",
+    "            print(\"> Result length\", len(result))\n",
+    "        assert len(result) == job.settings[\"limit\"]\n",
+    "        job.result_as_expected = True\n",
+    "        save_jobs(jobs)\n",
+    "    else:\n",
+    "        print(\"Expecting job to fail\")\n",
+    "        # with sy.raises(\n",
+    "        #     sy.SyftException(public_message=\"*UserCodeStatus.DENIED*\"), show=True\n",
+    "        # ):\n",
+    "        # with sy.raises(\n",
+    "        #     sy.SyftException, show=True\n",
+    "        # ):\n",
+    "        try:\n",
+    "            j = api_method(blocking=False)\n",
+    "            print(\"failed job didnt raise\", type(j))\n",
+    "            job.result_as_expected = False\n",
+    "        except Exception as e:\n",
+    "            job.result_as_expected = True\n",
+    "            print(\"failed job raised\", type(e))\n",
+    "\n",
+    "        save_jobs(jobs)"
    ]
   },
   {
@@ -182,10 +168,8 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(\"> got result2\", type(result2))\n",
-    "if hasattr(result2, \"__len__\"):\n",
-    "    # assert len(result2) == query_limit_size\n",
-    "    print(\"> result2 len\", len(result2))"
+    "expected_jobs = [job for job in jobs if job.result_as_expected]\n",
+    "len(expected_jobs)"
    ]
   },
   {
@@ -194,11 +178,9 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "print(\"where are my length prints\")\n",
-    "# stdlib\n",
-    "import time\n",
-    "\n",
-    "time.sleep(3)"
+    "# TODO fix\n",
+    "print(f\"got expected_jobs: {len(expected_jobs)} == reviewed_jobs: {len(reviewed_jobs)}\")\n",
+    "# assert len(reviewed_jobs) == len(expected_jobs)"
    ]
   },
   {
diff --git a/notebooks/scenarios/bigquery/job_helpers.py b/notebooks/scenarios/bigquery/job_helpers.py
new file mode 100644
index 00000000000..00afe5b9c50
--- /dev/null
+++ b/notebooks/scenarios/bigquery/job_helpers.py
@@ -0,0 +1,332 @@
+# stdlib
+from collections import defaultdict
+from collections.abc import Callable
+from dataclasses import dataclass
+from dataclasses import field
+import json
+import random
+import re
+import secrets
+import textwrap
+
+# third party
+from helpers import TestUser
+
+# syft absolute
+from syft import test_settings
+
+from syft.client.client import SyftClient  # noqa
+
+dataset_1 = test_settings.get("dataset_1", default="dataset_1")
+dataset_2 = test_settings.get("dataset_2", default="dataset_2")
+table_1 = test_settings.get("table_1", default="table_1")
+table_2 = test_settings.get("table_2", default="table_2")
+table_1_col_id = test_settings.get("table_1_col_id", default="table_id")
+table_1_col_score = test_settings.get("table_1_col_score", default="colname")
+table_2_col_id = test_settings.get("table_2_col_id", default="table_id")
+table_2_col_score = test_settings.get("table_2_col_score", default="colname")
+
+
+@dataclass
+class TestJob:
+    user_email: str
+    func_name: str
+    query: str
+    job_type: str
+    settings: dict  # make a type so we can rely on attributes
+    should_succeed: bool
+    should_submit: bool = True
+    code_path: str | None = field(default=None)
+    admin_reviewed: bool = False
+    result_as_expected: bool | None = None
+
+    _client_cache: SyftClient | None = field(default=None, repr=False, init=False)
+
+    @property
+    def is_submitted(self) -> bool:
+        return self.code_path is not None
+
+    @property
+    def client(self):
+        return self._client_cache
+
+    @client.setter
+    def client(self, client):
+        self._client_cache = client
+
+    def to_dict(self) -> dict:
+        output = {}
+        for k, v in self.__dict__.items():
+            if k.startswith("_"):
+                continue
+            output[k] = v
+        return output
+
+    def __iter__(self):
+        for key, val in self.to_dict().items():
+            if key.startswith("_"):
+                yield key, val
+
+    def __getitem__(self, key):
+        if key.startswith("_"):
+            return None
+        return self.to_dict()[key]
+
+    @property
+    def code_method(self) -> None | Callable:
+        try:
+            return getattr(self.client.code, self.func_name, None)
+        except Exception as e:
+            print(f"Cant find code method. {e}")
+        return None
+
+
+def make_query(settings: dict) -> str:
+    query = f"""
+    SELECT {settings['groupby_col']}, AVG({settings['score_col']}) AS average_score
+    FROM {settings['dataset']}.{settings['table']}
+    GROUP BY {settings['groupby_col']}
+    LIMIT {settings['limit']}""".strip()
+
+    return textwrap.dedent(query)
+
+
+def create_simple_query_job(user: TestUser) -> TestJob:
+    job_type = "simple_query"
+    func_name = f"{job_type}_{secrets.token_hex(3)}"
+
+    dataset = random.choice([dataset_1, dataset_2])
+    table, groupby_col, score_col = random.choice(
+        [
+            (table_1, table_1_col_id, table_1_col_score),
+            (table_2, table_2_col_id, table_2_col_score),
+        ]
+    )
+    limit = random.randint(1, 1_000_000)
+
+    settings = {
+        "dataset": dataset,
+        "table": table,
+        "groupby_col": groupby_col,
+        "score_col": score_col,
+        "limit": limit,
+    }
+    query = make_query(settings)
+
+    result = TestJob(
+        user_email=user.email,
+        func_name=func_name,
+        query=query,
+        job_type=job_type,
+        settings=settings,
+        should_succeed=True,
+    )
+
+    result.client = user.client
+    return result
+
+
+def create_wrong_asset_query(user: TestUser) -> TestJob:
+    job_type = "wrong_asset_query"
+    func_name = f"{job_type}_{secrets.token_hex(3)}"
+
+    valid_job = create_simple_query_job(user)
+    settings = valid_job.settings
+    corrupted_asset = random.choice(["dataset", "table"])
+    settings[corrupted_asset] = "wrong_asset"
+    query = make_query(settings)
+
+    result = TestJob(
+        user_email=user.email,
+        func_name=func_name,
+        query=query,
+        job_type=job_type,
+        settings=settings,
+        should_succeed=False,
+    )
+
+    result.client = user.client
+    return result
+
+
+def create_wrong_syntax_query(user: TestUser) -> TestJob:
+    job_type = "wrong_syntax_query"
+    func_name = f"{job_type}_{secrets.token_hex(3)}"
+
+    query = "SELECT * FROM table INCORRECT SYNTAX"
+
+    result = TestJob(
+        user_email=user.email,
+        func_name=func_name,
+        query=query,
+        job_type=job_type,
+        settings={},
+        should_succeed=False,
+    )
+
+    result.client = user.client
+    return result
+
+
+def create_long_query_job(user: TestUser) -> TestJob:
+    job_type = "job_too_much_text"
+    func_name = f"{job_type}_{secrets.token_hex(3)}"
+
+    query = "a" * 1_000
+
+    result = TestJob(
+        user_email=user.email,
+        func_name=func_name,
+        query=query,
+        job_type=job_type,
+        settings={},
+        should_succeed=False,
+    )
+
+    result.client = user.client
+    return result
+
+
+def create_query_long_name(user: TestUser) -> TestJob:
+    job_type = "job_long_name"
+    func_name = f"{job_type}_{secrets.token_hex(3)}"
+
+    job = create_simple_query_job(user)
+
+    job.job_type = job_type
+    job.func_name = func_name + "a" * 1_000
+
+    return job
+
+
+def create_job_funcname_xss(user: TestUser) -> TestJob:
+    job_type = "job_funcname_xss"
+    func_name = f"{job_type}_{secrets.token_hex(3)}"
+    func_name += "<script>alert('XSS in funcname')</script>"
+
+    job = create_simple_query_job(user)
+    job.job_type = job_type
+    job.func_name = func_name
+    job.should_submit = False
+    return job
+
+
+def create_job_query_xss(user: TestUser) -> TestJob:
+    job_type = "job_query_xss"
+    func_name = f"{job_type}_{secrets.token_hex(3)}"
+
+    job = create_simple_query_job(user)
+    job.job_type = job_type
+    job.func_name = func_name
+    job.query += "<script>alert('XSS in query')</script>"
+    job.should_succeed = False
+
+    return job
+
+
+def create_job_many_columns(user: TestUser) -> TestJob:
+    job_type = "job_many_columns"
+    func_name = f"{job_type}_{secrets.token_hex(3)}"
+
+    job = create_simple_query_job(user)
+    job.job_type = job_type
+    job.func_name = func_name
+    settings = job.settings
+    job.settings["num_extra_cols"] = random.randint(100, 1000)
+
+    new_columns_string = ", ".join(
+        f"{settings['score_col']} as col_{i}" for i in range(settings["num_extra_cols"])
+    )
+
+    job.query = f"""
+    SELECT {settings['groupby_col']}, AVG({settings['score_col']}) AS average_score, {new_columns_string}
+    FROM {settings['dataset']}.{settings['table']}
+    GROUP BY {settings['groupby_col']}
+    LIMIT {settings['limit']}""".strip()
+
+    return job
+
+
+def create_job(user: TestUser) -> TestJob:
+    job_func = random.choice(create_job_functions)
+    return job_func(user)
+
+
+def create_jobs(users: list[TestUser], n_per_user: int = 10) -> list[TestJob]:
+    jobs = []
+    num_users = len(users)
+    total_jobs = n_per_user * num_users
+    user_index = 0
+    each_count = 0
+    # keep making jobs until we have enough
+    while len(jobs) < total_jobs:
+        # if we havent used each job type yet keep getting the next one
+        if each_count < len(create_job_functions):
+            job_func = create_job_functions[each_count]
+            each_count += 1
+        else:
+            # otherwise lets get a random one
+            job_func = create_job
+        # use the current index of user
+        jobs.append(job_func(users[user_index]))
+
+        # only go as high as the last user index
+        if user_index < num_users - 1:
+            user_index += 1
+        else:
+            # reset back to the first user
+            user_index = 0
+
+    # in case we stuffed up
+    if len(jobs) > total_jobs:
+        jobs = jobs[:total_jobs]
+    return jobs
+
+
+def extract_code_path(response) -> str | None:
+    pattern = r"client\.code\.(\w+)\(\)"
+    match = re.search(pattern, str(response))
+    if match:
+        extracted_code = match.group(1)
+        return extracted_code
+    return None
+
+
+create_job_functions = [
+    create_simple_query_job,
+    # create_wrong_asset_query,
+    create_wrong_syntax_query,
+    create_long_query_job,
+    create_query_long_name,
+    create_job_funcname_xss,
+    create_job_query_xss,
+    create_job_many_columns,
+]
+
+
+def save_jobs(jobs, filepath="./jobs.json"):
+    user_jobs = defaultdict(list)
+    for job in jobs:
+        user_jobs[job.user_email].append(job.to_dict())
+    with open(filepath, "w") as f:
+        f.write(json.dumps(user_jobs))
+
+
+def load_jobs(users, high_client, filepath="./jobs.json"):
+    data = {}
+    try:
+        with open(filepath) as f:
+            data = json.loads(f.read())
+    except Exception as e:
+        print(f"cant read file: {filepath}: {e}")
+        data = {}
+    jobs_list = []
+    for user in users:
+        user_jobs = data[user.email]
+        for user_job in user_jobs:
+            test_job = TestJob(**user_job)
+            if user._client_cache is None:
+                user.client = high_client
+            test_job.client = user.client
+            jobs_list.append(test_job)
+    return jobs_list