diff --git a/src/electron/renderer/src/server/globals.ts b/src/electron/renderer/src/server/globals.ts
index 698243dc9..535c4d823 100644
--- a/src/electron/renderer/src/server/globals.ts
+++ b/src/electron/renderer/src/server/globals.ts
@@ -56,7 +56,7 @@ export const activateServer = () => {
 export const serverGlobals = {
     species: new Promise((res, rej) => {
       onServerOpen(() => {
-        fetch(new URL("get-recommended-species", baseUrl))
+        fetch(new URL("/dandi/get-recommended-species", baseUrl))
           .then((res) => res.json())
           .then((species) => {
             res(species)
@@ -67,7 +67,7 @@ export const serverGlobals = {
     }),
     cpus: new Promise((res, rej) => {
       onServerOpen(() => {
-        fetch(new URL("cpus", baseUrl))
+        fetch(new URL("/system/cpus", baseUrl))
           .then((res) => res.json())
           .then((cpus) => {
             res(cpus)
diff --git a/src/electron/renderer/src/stories/pages/preview/PreviewPage.js b/src/electron/renderer/src/stories/pages/preview/PreviewPage.js
index 4436038cd..e6de3b95a 100644
--- a/src/electron/renderer/src/stories/pages/preview/PreviewPage.js
+++ b/src/electron/renderer/src/stories/pages/preview/PreviewPage.js
@@ -18,7 +18,12 @@ export class PreviewPage extends Page {
 
     updatePath = async (path) => {
         if (path) {
-            const result = await fetch(`${baseUrl}/files/${path}`, { method: "POST" }).then((res) => res.text());
+            // Enable access to the explicit file path
+            const result = await fetch(`${baseUrl}/files/${path}`, {
+                method: "POST",
+            }).then((res) => res.text());
+
+            // Set Neurosift to access the returned URL
             if (result) this.neurosift.url = result;
         } else this.neurosift.url = undefined;
     };
diff --git a/src/electron/renderer/src/stories/preview/NWBFilePreview.js b/src/electron/renderer/src/stories/preview/NWBFilePreview.js
index cb496d591..cd268a90e 100644
--- a/src/electron/renderer/src/stories/preview/NWBFilePreview.js
+++ b/src/electron/renderer/src/stories/preview/NWBFilePreview.js
@@ -56,7 +56,10 @@ class NWBPreviewInstance extends LitElement {
         const isOnline = navigator.onLine;
 
         return isOnline
-            ? new Neurosift({ url: getURLFromFilePath(this.file, this.project), fullscreen: false })
+            ? new Neurosift({
+                  url: getURLFromFilePath(this.file, this.project),
+                  fullscreen: false,
+              })
             : until(
                   (async () => {
                       const htmlRep = await run("html", { nwbfile_path: this.file }, { swal: false });
diff --git a/src/electron/renderer/src/stories/preview/Neurosift.js b/src/electron/renderer/src/stories/preview/Neurosift.js
index c70c9d5fc..3f85327d8 100644
--- a/src/electron/renderer/src/stories/preview/Neurosift.js
+++ b/src/electron/renderer/src/stories/preview/Neurosift.js
@@ -80,7 +80,9 @@ export class Neurosift extends LitElement {
     render() {
         return this.url
             ? html` <div class="loader-container">
-                      ${new Loader({ message: `Loading Neurosift view...<br/><small>${this.url}</small>` })}
+                      ${new Loader({
+                          message: `Loading Neurosift view...<br/><small>${this.url}</small>`,
+                      })}
                   </div>
                   ${this.fullscreen ? new FullScreenToggle({ target: this }) : ""}
                   <iframe
diff --git a/src/pyflask/apis/__init__.py b/src/pyflask/apis/__init__.py
deleted file mode 100644
index f492dc7df..000000000
--- a/src/pyflask/apis/__init__.py
+++ /dev/null
@@ -1,3 +0,0 @@
-from .data import data_api
-from .neuroconv import neuroconv_api
-from .startup import startup_api
diff --git a/src/pyflask/app.py b/src/pyflask/app.py
index 9929ce625..933a70975 100644
--- a/src/pyflask/app.py
+++ b/src/pyflask/app.py
@@ -1,5 +1,6 @@
 """The primary Flask server for the Python backend."""
 
+import collections
 import json
 import multiprocessing
 import sys
@@ -10,13 +11,12 @@
 from os.path import isabs
 from pathlib import Path
 from signal import SIGINT
+from typing import Union
 from urllib.parse import unquote
 
 # https://stackoverflow.com/questions/32672596/pyinstaller-loads-script-multiple-times#comment103216434_32677108
 multiprocessing.freeze_support()
 
-
-from apis import data_api, neuroconv_api, startup_api
 from flask import Flask, request, send_file, send_from_directory
 from flask_cors import CORS
 from flask_restx import Api, Resource
@@ -27,12 +27,22 @@
     is_packaged,
     resource_path,
 )
+from namespaces import (
+    dandi_namespace,
+    data_namespace,
+    neuroconv_namespace,
+    neurosift_namespace,
+    startup_namespace,
+    system_namespace,
+)
 
-app = Flask(__name__)
+neurosift_file_registry = collections.defaultdict(bool)
+
+flask_app = Flask(__name__)
 
 # Always enable CORS to allow distinct processes to handle frontend vs. backend
-CORS(app)
-app.config["CORS_HEADERS"] = "Content-Type"
+CORS(flask_app)
+flask_app.config["CORS_HEADERS"] = "Content-Type"
 
 # Create logger configuration
 LOG_FOLDER = Path(GUIDE_ROOT_FOLDER, "logs")
@@ -50,63 +60,39 @@
     title="NWB GUIDE API",
     description="The REST API for the NWB GUIDE provided by the Python Flask Server.",
 )
-api.add_namespace(startup_api)
-api.add_namespace(neuroconv_api)
-api.add_namespace(data_api)
-api.init_app(app)
+api.add_namespace(startup_namespace)
+api.add_namespace(neuroconv_namespace)
+api.add_namespace(data_namespace)
+api.add_namespace(system_namespace)
+api.add_namespace(dandi_namespace)
+# api.add_namespace(neurosift_namespace)  # TODO: enable later
+api.init_app(flask_app)
 
-registered = {}
 
+@flask_app.route("/preview/<path:file_path>")
+def send_preview(file_path):
+    return send_from_directory(directory=STUB_SAVE_FOLDER_PATH, path=file_path)
 
-@app.route("/files")
-def get_all_files():
-    return list(registered.keys())
 
+@flask_app.route("/files/<path:file_path>", methods=["GET", "POST"])
+def handle_file_request(file_path) -> Union[str, None]:
+    if ".nwb" not in file_path:
+        raise ValueError("This endpoint must be called on an NWB file!")
 
-@app.route("/files/<path:path>", methods=["GET", "POST"])
-def handle_file_request(path):
     if request.method == "GET":
-        if registered[path]:
-            path = unquote(path)
-            if not isabs(path):
-                path = f"/{path}"
-            return send_file(path)
+        if neurosift_file_registry[file_path] is True:
+            file_path = unquote(file_path)
+            if not isabs(file_path):
+                file_path = f"/{file_path}"
+
+            return send_file(path_or_file=file_path)
         else:
             app.abort(404, "Resource is not accessible.")
 
     else:
-        if ".nwb" in path:
-            registered[path] = True
-            return request.base_url
-        else:
-            app.abort(400, str("Path does not point to an NWB file."))
-
-
-@app.route("/conversions/<path:path>")
-def send_conversions(path):
-    return send_from_directory(CONVERSION_SAVE_FOLDER_PATH, path)
-
-
-@app.route("/preview/<path:path>")
-def send_preview(path):
-    return send_from_directory(STUB_SAVE_FOLDER_PATH, path)
-
-
-@app.route("/cpus")
-def get_cpu_count():
-    from psutil import cpu_count
-
-    physical = cpu_count(logical=False)
-    logical = cpu_count()
-
-    return dict(physical=physical, logical=logical)
-
-
-@app.route("/get-recommended-species")
-def get_species():
-    from dandi.metadata.util import species_map
+        neurosift_file_registry[file_path] = True
 
-    return species_map
+        return request.base_url
 
 
 @api.route("/log")
@@ -154,13 +140,13 @@ def get(self):
         )
         log_handler.setFormatter(log_formatter)
 
-        app.logger.addHandler(log_handler)
-        app.logger.setLevel(DEBUG)
+        flask_app.logger.addHandler(log_handler)
+        flask_app.logger.setLevel(DEBUG)
 
-        app.logger.info(f"Logging to {LOG_FILE_PATH}")
+        flask_app.logger.info(f"Logging to {LOG_FILE_PATH}")
 
         # Run the server
         api.logger.info(f"Starting server on port {port}")
-        app.run(host="127.0.0.1", port=port)
+        flask_app.run(host="127.0.0.1", port=port)
     else:
         raise Exception("No port provided for the NWB GUIDE backend.")
diff --git a/src/pyflask/namespaces/__init__.py b/src/pyflask/namespaces/__init__.py
new file mode 100644
index 000000000..0f1edb274
--- /dev/null
+++ b/src/pyflask/namespaces/__init__.py
@@ -0,0 +1,6 @@
+from .dandi import dandi_namespace
+from .data import data_namespace
+from .neuroconv import neuroconv_namespace
+from .neurosift import neurosift_namespace
+from .startup import startup_namespace
+from .system import system_namespace
diff --git a/src/pyflask/namespaces/dandi.py b/src/pyflask/namespaces/dandi.py
new file mode 100644
index 000000000..8056a12c3
--- /dev/null
+++ b/src/pyflask/namespaces/dandi.py
@@ -0,0 +1,24 @@
+"""An API for handling requests to the DANDI Python API."""
+
+from typing import List, Tuple, Union
+
+import flask_restx
+
+dandi_namespace = flask_restx.Namespace(
+    name="dandi", description="Request various static listings from the DANDI Python API."
+)
+
+
+@dandi_namespace.route("/get-recommended-species")
+class SupportedSpecies(flask_restx.Resource):
+
+    @dandi_namespace.doc(
+        description=(
+            "Request the list of currently supported species (by Latin Binomial name) for DANDI. Note that any "
+            "explicit NCBI taxonomy link is also supported."
+        ),
+    )
+    def get(self) -> Union[List[Tuple[List[str], str, str, str]], None]:
+        from dandi.metadata.util import species_map
+
+        return species_map
diff --git a/src/pyflask/apis/data.py b/src/pyflask/namespaces/data.py
similarity index 67%
rename from src/pyflask/apis/data.py
rename to src/pyflask/namespaces/data.py
index 7cdafdb57..8b05339e9 100644
--- a/src/pyflask/apis/data.py
+++ b/src/pyflask/namespaces/data.py
@@ -5,10 +5,10 @@
 from flask_restx import Namespace, Resource, reqparse
 from manageNeuroconv import generate_dataset, generate_test_data
 
-data_api = Namespace("data", description="API route for dataset generation in the NWB GUIDE.")
+data_namespace = Namespace("data", description="API route for dataset generation in the NWB GUIDE.")
 
 
-@data_api.errorhandler(Exception)
+@data_namespace.errorhandler(Exception)
 def exception_handler(error):
     exceptiondata = traceback.format_exception(type(error), error, error.__traceback__)
     return {"message": exceptiondata[-1], "traceback": "".join(exceptiondata)}
@@ -18,16 +18,16 @@ def exception_handler(error):
 generate_test_data_parser.add_argument("output_path", type=str, required=True)
 
 
-@data_api.route("/generate")
-@data_api.expect(generate_test_data_parser)
+@data_namespace.route("/generate")
+@data_namespace.expect(generate_test_data_parser)
 class GeneratetestData(Resource):
-    @data_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @data_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         try:
             arguments = generate_test_data_parser.parse_args()
             generate_test_data(output_path=arguments["output_path"])
         except Exception as exception:
-            data_api.abort(500, str(exception))
+            data_namespace.abort(500, str(exception))
             raise exception
 
 
@@ -36,14 +36,14 @@ def post(self):
 generate_test_dataset_parser.add_argument("input_path", type=str, required=True)
 
 
-@data_api.route("/generate/dataset")
-@data_api.expect(generate_test_data_parser)
+@data_namespace.route("/generate/dataset")
+@data_namespace.expect(generate_test_data_parser)
 class GenerateDataset(Resource):
-    @data_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @data_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         try:
             arguments = generate_test_dataset_parser.parse_args()
             return generate_dataset(input_path=arguments["input_path"], output_path=arguments["output_path"])
 
         except Exception as exception:
-            data_api.abort(500, str(exception))
+            data_namespace.abort(500, str(exception))
diff --git a/src/pyflask/apis/neuroconv.py b/src/pyflask/namespaces/neuroconv.py
similarity index 52%
rename from src/pyflask/apis/neuroconv.py
rename to src/pyflask/namespaces/neuroconv.py
index 47a2af031..79d4473bd 100644
--- a/src/pyflask/apis/neuroconv.py
+++ b/src/pyflask/namespaces/neuroconv.py
@@ -24,21 +24,21 @@
 )
 from manageNeuroconv.info import announcer
 
-neuroconv_api = Namespace("neuroconv", description="Neuroconv neuroconv_api for the NWB GUIDE.")
+neuroconv_namespace = Namespace("neuroconv", description="Neuroconv neuroconv_namespace for the NWB GUIDE.")
 
 parser = reqparse.RequestParser()
 parser.add_argument("interfaces", type=str, action="split", help="Interfaces cannot be converted")
 
 
-@neuroconv_api.errorhandler(Exception)
+@neuroconv_namespace.errorhandler(Exception)
 def exception_handler(error):
     exceptiondata = traceback.format_exception(type(error), error, error.__traceback__)
     return {"message": exceptiondata[-1], "traceback": "".join(exceptiondata)}
 
 
-@neuroconv_api.route("/")
+@neuroconv_namespace.route("/")
 class AllInterfaces(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def get(self):
         try:
             # return get_all_interface_info()
@@ -49,75 +49,75 @@ def get(self):
                 **get_all_converter_info(),
             }
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
             raise exception
 
 
-@neuroconv_api.route("/schema")
+@neuroconv_namespace.route("/schema")
 class Schemas(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         try:
-            return get_source_schema(neuroconv_api.payload)
+            return get_source_schema(neuroconv_namespace.payload)
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
 
 
-@neuroconv_api.route("/locate")
+@neuroconv_namespace.route("/locate")
 class LocateData(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         try:
-            return locate_data(neuroconv_api.payload)
+            return locate_data(neuroconv_namespace.payload)
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
 
 
-@neuroconv_api.route("/locate/autocomplete")
+@neuroconv_namespace.route("/locate/autocomplete")
 class AutoCompleteFormatString(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         try:
-            return autocomplete_format_string(neuroconv_api.payload)
+            return autocomplete_format_string(neuroconv_namespace.payload)
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
 
 
-@neuroconv_api.route("/metadata")
+@neuroconv_namespace.route("/metadata")
 class Metadata(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         try:
             return get_metadata_schema(
-                neuroconv_api.payload.get("source_data"), neuroconv_api.payload.get("interfaces")
+                neuroconv_namespace.payload.get("source_data"), neuroconv_namespace.payload.get("interfaces")
             )
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
 
 
-@neuroconv_api.route("/convert")
+@neuroconv_namespace.route("/convert")
 class Convert(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         try:
-            return convert_to_nwb(neuroconv_api.payload)
+            return convert_to_nwb(neuroconv_namespace.payload)
 
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
 
 
-@neuroconv_api.route("/alignment")
+@neuroconv_namespace.route("/alignment")
 class Alignment(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         try:
-            return get_interface_alignment(neuroconv_api.payload)
+            return get_interface_alignment(neuroconv_namespace.payload)
 
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
 
 
-validate_parser = neuroconv_api.parser()
+validate_parser = neuroconv_namespace.parser()
 validate_parser.add_argument("parent", type=dict, required=True)
 validate_parser.add_argument("function_name", type=str, required=True)
 
@@ -125,27 +125,27 @@ def post(self):
 # await fetch('neuroconv/validate', {method:"POST", body: JSON.stringify({nwb_file_object: {related_publications: ['name']}, function: 'check_doi_publications'}), headers: {
 #     "Content-Type": "application/json",
 #   }}).then(res => res.text())
-@neuroconv_api.route("/validate")
-@neuroconv_api.expect(validate_parser)
+@neuroconv_namespace.route("/validate")
+@neuroconv_namespace.expect(validate_parser)
 class Validate(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         try:
             args = validate_parser.parse_args()
             return validate_metadata(args.get("parent"), args.get("function_name"))
 
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
 
 
-@neuroconv_api.route("/upload/project")
+@neuroconv_namespace.route("/upload/project")
 class UploadProject(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         try:
             import psutil
 
-            upload_options = neuroconv_api.payload
+            upload_options = neuroconv_namespace.payload
             if "number_of_jobs" not in upload_options:
                 upload_options.update(number_of_jobs=1)
             if "number_of_threads" not in upload_options:
@@ -154,17 +154,17 @@ def post(self):
             return upload_project_to_dandi(**upload_options)
 
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
 
 
-@neuroconv_api.route("/upload/folder")
+@neuroconv_namespace.route("/upload/folder")
 class UploadFolder(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         try:
             import psutil
 
-            upload_options = neuroconv_api.payload
+            upload_options = neuroconv_namespace.payload
             if "number_of_jobs" not in upload_options:
                 upload_options.update(number_of_jobs=1)
             if "number_of_threads" not in upload_options:
@@ -173,77 +173,77 @@ def post(self):
             return upload_folder_to_dandi(**upload_options)
 
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
 
 
-@neuroconv_api.route("/upload")
+@neuroconv_namespace.route("/upload")
 class Upload(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         from os.path import isdir
 
         try:
-            paths = neuroconv_api.payload["filesystem_paths"]
+            paths = neuroconv_namespace.payload["filesystem_paths"]
 
             if len(paths) == 1 and isdir(paths[0]):
-                kwargs = {**neuroconv_api.payload}
+                kwargs = {**neuroconv_namespace.payload}
                 del kwargs["filesystem_paths"]
                 kwargs["nwb_folder_path"] = paths[0]
                 return upload_folder_to_dandi(**kwargs)
 
             else:
-                return upload_multiple_filesystem_objects_to_dandi(**neuroconv_api.payload)
+                return upload_multiple_filesystem_objects_to_dandi(**neuroconv_namespace.payload)
 
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
 
 
-@neuroconv_api.route("/inspect_file")
+@neuroconv_namespace.route("/inspect_file")
 class InspectNWBFile(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         try:
-            return inspect_nwb_file(neuroconv_api.payload)
+            return inspect_nwb_file(neuroconv_namespace.payload)
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
 
 
-@neuroconv_api.route("/inspect_folder")
+@neuroconv_namespace.route("/inspect_folder")
 class InspectNWBFolder(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         try:
             url = f"{request.url_root}neuroconv/announce"
-            return inspect_nwb_folder(url, neuroconv_api.payload)
+            return inspect_nwb_folder(url, neuroconv_namespace.payload)
 
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
 
 
-@neuroconv_api.route("/announce")
+@neuroconv_namespace.route("/announce")
 class InspectNWBFolder(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         try:
-            data = neuroconv_api.payload
+            data = neuroconv_namespace.payload
             announcer.announce(data)
             return True
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
 
 
-@neuroconv_api.route("/inspect")
+@neuroconv_namespace.route("/inspect")
 class InspectNWBFolder(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         from os.path import isfile
 
         url = f"{request.url_root}neuroconv/announce"
 
         try:
-            paths = neuroconv_api.payload["paths"]
+            paths = neuroconv_namespace.payload["paths"]
 
-            kwargs = {**neuroconv_api.payload}
+            kwargs = {**neuroconv_namespace.payload}
             del kwargs["paths"]
 
             if len(paths) == 1:
@@ -256,32 +256,32 @@ def post(self):
                 return inspect_multiple_filesystem_objects(url, paths, **kwargs)
 
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
 
 
-@neuroconv_api.route("/html")
+@neuroconv_namespace.route("/html")
 class NWBToHTML(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         try:
             from pynwb import NWBHDF5IO
 
-            with NWBHDF5IO(neuroconv_api.payload.nwbfile_path, mode="r") as io:
+            with NWBHDF5IO(neuroconv_namespace.payload.nwbfile_path, mode="r") as io:
                 html = io.read()._repr_html_()
             return html
 
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
 
 
 # Create an events endpoint
 # announcer.announce('test', 'publish')
-@neuroconv_api.route("/events", methods=["GET"])
+@neuroconv_namespace.route("/events", methods=["GET"])
 class Events(Resource):
-    @neuroconv_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @neuroconv_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def get(self):
         try:
             return Response(listen_to_neuroconv_events(), mimetype="text/event-stream")
 
         except Exception as exception:
-            neuroconv_api.abort(500, str(exception))
+            neuroconv_namespace.abort(500, str(exception))
diff --git a/src/pyflask/namespaces/neurosift.py b/src/pyflask/namespaces/neurosift.py
new file mode 100644
index 000000000..117237092
--- /dev/null
+++ b/src/pyflask/namespaces/neurosift.py
@@ -0,0 +1,75 @@
+"""
+An API for handling file system communication with the standalone Neurosift preview page.
+
+NOTE: not currently used due to ongoing issues
+"""
+
+import collections
+import os
+import urllib
+from typing import Union
+
+import flask
+import flask_restx
+from manageNeuroconv.info import STUB_SAVE_FOLDER_PATH
+
+neurosift_namespace = flask_restx.Namespace(
+    name="neurosift", description="Handle file system communication with the " "standalone Neurosift preview page."
+)
+
+# A global in-memory registry of NWB files - much faster than asking if file is in a global list
+# Keys are NWB files; values are booleans indicating if the base URL has been exposed for that file
+neurosift_file_registry = collections.defaultdict(bool)
+
+
+def _error_if_not_nwb_file(file_path: str) -> None:
+    if ".nwb" not in file_path:
+        raise ValueError("This endpoint must be called on an NWB file!")
+
+    return
+
+
+@neurosift_namespace.route("/files/<path:file_path>")
+@neurosift_namespace.doc(
+    description="Handle adding and fetching NWB files from the global file registry.",
+)
+class NeurosiftFileManager(flask_restx.Resource):
+
+    @neurosift_namespace.doc(
+        description="If the file path has been added to the registry (and therefore sent its base "
+        "URL), return the absolute file path. This is implicitly called by Neurosift.",
+    )
+    def get(self, file_path: str) -> Union[flask.Response, None]:
+        _error_if_not_nwb_file(file_path=file_path)
+
+        if not neurosift_file_registry[file_path]:
+            code = 404
+            base_message = server_error_responses(codes=[code])[code]
+            message = f"{base_message}: The base URL has not been exposed for this NWB file."
+            api.abort(code=code, message=message)
+
+            return
+
+        # Decode any URL encoding applied to the file path
+        parsed_file_path = urllib.parse.unquote(file_path)
+
+        # Check if the file path is relative
+        is_file_relative = not os.path.isabs(parsed_file_path)
+        if is_file_relative:
+            parsed_file_path = f"/{parsed_file_path}"
+
+        return flask.send_file(path_or_file=parsed_file_path)
+
+    @neurosift_namespace.doc(
+        description=(
+            "Add the file to a global in-memory registry (refreshes on App restart) and return "
+            "the base URL of the newly added file.",
+        )
+    )
+    def post(self, file_path: str) -> Union[str, None]:
+        _error_if_not_nwb_file(file_path=file_path)
+
+        neurosift_file_registry[file_path] = True
+        # if neurosift_file_registry[file_path] = True:
+        #     raise ValueError(flask.request.base_url)
+        return flask.request.base_url
diff --git a/src/pyflask/apis/startup.py b/src/pyflask/namespaces/startup.py
similarity index 68%
rename from src/pyflask/apis/startup.py
rename to src/pyflask/namespaces/startup.py
index 823dbee00..927a938f1 100644
--- a/src/pyflask/apis/startup.py
+++ b/src/pyflask/namespaces/startup.py
@@ -2,9 +2,9 @@
 
 from flask_restx import Namespace, Resource
 
-startup_api = Namespace("startup", description="API for startup commands related to the NWB GUIDE.")
+startup_namespace = Namespace("startup", description="API for startup commands related to the NWB GUIDE.")
 
-parser = startup_api.parser()
+parser = startup_namespace.parser()
 parser.add_argument(
     "arg",
     type=str,
@@ -14,15 +14,15 @@
 )
 
 
-@startup_api.route("/echo")
+@startup_namespace.route("/echo")
 class Echo(Resource):
-    @startup_api.expect(parser)
+    @startup_namespace.expect(parser)
     def get(self):
         args = parser.parse_args()
         return args["arg"]
 
 
-@startup_api.route("/preload-imports")
+@startup_namespace.route("/preload-imports")
 class PreloadImports(Resource):
     """
     Preload various imports on startup instead of waiting for them later on.
@@ -32,12 +32,12 @@ class PreloadImports(Resource):
     simply expose the cached namespaces to their scope instead of retriggering the entire import.
     """
 
-    @startup_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @startup_namespace.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def get(self):
         try:
             import neuroconv
 
             return True
         except Exception as exception:
-            startup_api.abort(500, str(exception))
+            startup_namespace.abort(500, str(exception))
             raise exception
diff --git a/src/pyflask/namespaces/system.py b/src/pyflask/namespaces/system.py
new file mode 100644
index 000000000..491cf36aa
--- /dev/null
+++ b/src/pyflask/namespaces/system.py
@@ -0,0 +1,22 @@
+"""An API for handling general system information."""
+
+from typing import Dict, Union
+
+import flask_restx
+
+system_namespace = flask_restx.Namespace(name="system", description="Request various system specific information.")
+
+
+@system_namespace.route("/cpus")
+class GetCPUInfo(flask_restx.Resource):
+
+    @system_namespace.doc(
+        description="Request the number of physical and logical cores on the system.",
+    )
+    def get(self) -> Union[Dict[str, int], None]:
+        from psutil import cpu_count
+
+        physical = cpu_count(logical=False)
+        logical = cpu_count()
+
+        return dict(physical=physical, logical=logical)
diff --git a/src/pyflask/tests/conftest.py b/src/pyflask/tests/conftest.py
index ec72c792b..fca69482c 100644
--- a/src/pyflask/tests/conftest.py
+++ b/src/pyflask/tests/conftest.py
@@ -12,7 +12,7 @@ def client(request):
     if target:
         return target
     else:
-        app = flask.app
+        app = flask.flask_app
         app.config.update(
             {
                 "TESTING": True,
diff --git a/src/schemas/dandi-upload.schema.ts b/src/schemas/dandi-upload.schema.ts
index cb0538578..fc251b467 100644
--- a/src/schemas/dandi-upload.schema.ts
+++ b/src/schemas/dandi-upload.schema.ts
@@ -28,7 +28,7 @@ export const ready = {
 
 //  Get CPUs
 onServerOpen(async () => {
-    await fetch(new URL("cpus", baseUrl))
+    await fetch(new URL("/system/cpus", baseUrl))
     .then((res) => res.json())
     .then(({ physical, logical }) => {
         const { number_of_jobs, number_of_threads } = additionalSettings as any;