diff --git a/src/__init__.py b/src/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/electron/renderer/src/server/globals.ts b/src/electron/renderer/src/server/globals.ts
index 698243dc9..af69d9af9 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 a8e6a320a..868b279ac 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 4bc8b7b71..9a82e8880 100644
--- a/src/electron/renderer/src/stories/preview/NWBFilePreview.js
+++ b/src/electron/renderer/src/stories/preview/NWBFilePreview.js
@@ -1,12 +1,13 @@
 import { LitElement, css, html } from "lit";
 import { InspectorList } from "./inspector/InspectorList";
-import { Neurosift, getURLFromFilePath } from "./Neurosift";
+import { Neurosift } from "./Neurosift";
 import { unsafeHTML } from "lit/directives/unsafe-html.js";
 import { run } from "../pages/guided-mode/options/utils";
 import { until } from "lit/directives/until.js";
 import { InstanceManager } from "../InstanceManager";
 import { path } from "../../electron";
 import { FullScreenToggle } from "../FullScreenToggle";
+import { baseUrl } from "../../server/globals";
 
 export function getSharedPath(array) {
     array = array.map((str) => str.replace(/\\/g, "/")); // Convert to Mac-style path
@@ -55,15 +56,26 @@ class NWBPreviewInstance extends LitElement {
     render() {
         const isOnline = navigator.onLine;
 
-        return isOnline
-            ? new Neurosift({ url: getURLFromFilePath(this.file, this.project), fullscreen: false })
-            : until(
-                  (async () => {
-                      const htmlRep = await run("html", { nwbfile_path: this.file }, { swal: false });
-                      return unsafeHTML(htmlRep);
-                  })(),
-                  html`<small>Loading HTML representation...</small>`
-              );
+        if (!isOnline)
+            return until(
+                (async () => {
+                    const htmlRep = await run("html", { nwbfile_path: this.file }, { swal: false });
+                    return unsafeHTML(htmlRep);
+                })(),
+                html`<small>Loading HTML representation...</small>`
+            );
+
+        const neurosift = new Neurosift({ fullscreen: false });
+
+        // Enable access to the explicit file path
+        fetch(`${baseUrl}/files/${this.file}`, { method: "POST" })
+            .then((res) => res.text())
+            .then((result) => {
+                // Set Neurosift to access the returned URL
+                if (result) neurosift.url = result;
+            });
+
+        return neurosift;
     }
 }
 
diff --git a/src/electron/renderer/src/stories/preview/Neurosift.js b/src/electron/renderer/src/stories/preview/Neurosift.js
index 8def8c8dd..ecce4cbb9 100644
--- a/src/electron/renderer/src/stories/preview/Neurosift.js
+++ b/src/electron/renderer/src/stories/preview/Neurosift.js
@@ -2,12 +2,6 @@ import { LitElement, css, html } from "lit";
 
 import { Loader } from "../Loader";
 import { FullScreenToggle } from "../FullScreenToggle";
-import { baseUrl } from "../../server/globals";
-
-export function getURLFromFilePath(file, projectName) {
-    const regexp = new RegExp(`.+(${projectName}.+)`);
-    return `${baseUrl}/preview/${file.match(regexp)[1]}`;
-}
 
 export class Neurosift extends LitElement {
     static get styles() {
@@ -80,7 +74,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/__init__.py b/src/pyflask/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/pyflask/apis/__init__.py b/src/pyflask/apis/__init__.py
index f492dc7df..f8f83c054 100644
--- a/src/pyflask/apis/__init__.py
+++ b/src/pyflask/apis/__init__.py
@@ -1,3 +1,15 @@
+from .dandi import dandi_api
 from .data import data_api
 from .neuroconv import neuroconv_api
+from .neurosift import neurosift_api
 from .startup import startup_api
+from .system import system_api
+
+__all__ = [
+    "neurosift_api",
+    "dandi_api",
+    "system_api",
+    "data_api",
+    "neuroconv_api",
+    "startup_api",
+]
diff --git a/src/pyflask/apis/dandi.py b/src/pyflask/apis/dandi.py
new file mode 100644
index 000000000..003852c3a
--- /dev/null
+++ b/src/pyflask/apis/dandi.py
@@ -0,0 +1,26 @@
+"""An API for handling requests to the DANDI Python API."""
+
+from typing import List, Tuple, Union
+
+import flask_restx
+
+from .utils import catch_exception_and_abort, server_error_responses
+
+dandi_api = flask_restx.Namespace(
+    name="dandi", description="Request various static listings from the DANDI Python API."
+)
+
+
+@dandi_api.route(rule="/get-recommended-species")
+class SupportedSpecies(flask_restx.Resource):
+
+    @dandi_api.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.",
+        responses=server_error_responses(codes=[200, 500]),
+    )
+    @catch_exception_and_abort(api=dandi_api, code=500)
+    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/apis/data.py
index f557f970f..e57a9538f 100644
--- a/src/pyflask/apis/data.py
+++ b/src/pyflask/apis/data.py
@@ -2,17 +2,16 @@
 
 import traceback
 
-from apis.utils import catch_exception_and_abort
 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_api = Namespace(name="data", description="API route for dataset generation in the NWB GUIDE.")
 
 
 @data_api.errorhandler(Exception)
 def exception_handler(error):
     exceptiondata = traceback.format_exception(type(error), error, error.__traceback__)
-    return {"message": exceptiondata[-1], "traceback": "".join(exceptiondata)}
+    return {"message": exceptiondata[-1], "traceback": "".join(exceptiondata)}, 500
 
 
 generate_test_data_parser = reqparse.RequestParser()
@@ -22,13 +21,17 @@ def exception_handler(error):
 @data_api.route("/generate")
 @data_api.expect(generate_test_data_parser)
 class GeneratetestData(Resource):
-    @data_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
 
-    # @catch_exception_and_abort(api=data_api, code=500)
+    @data_api.doc(
+        description="Generate example ecephys data using SpikeInterface.",
+    )
+    def post(self):
+        arguments = generate_test_data_parser.parse_args()
+
+    @data_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
     def post(self):
         arguments = generate_test_data_parser.parse_args()
 
-        raise NotImplementedError("test")
         generate_test_data(output_path=arguments["output_path"])
 
 
@@ -40,10 +43,8 @@ def post(self):
 @data_api.route("/generate/dataset")
 @data_api.expect(generate_test_data_parser)
 class GenerateDataset(Resource):
-    @data_api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
-    @catch_exception_and_abort(api=data_api, code=500)
+
     def post(self):
         arguments = generate_test_dataset_parser.parse_args()
 
-        raise NotImplementedError("test2")
         return generate_dataset(input_path=arguments["input_path"], output_path=arguments["output_path"])
diff --git a/src/pyflask/apis/neuroconv.py b/src/pyflask/apis/neuroconv.py
index 47a2af031..98d85798b 100644
--- a/src/pyflask/apis/neuroconv.py
+++ b/src/pyflask/apis/neuroconv.py
@@ -1,6 +1,7 @@
 """API endpoint definitions for interacting with NeuroConv."""
 
 import traceback
+from typing import Dict
 
 from flask import Response, request
 from flask_restx import Namespace, Resource, reqparse
@@ -24,16 +25,18 @@
 )
 from manageNeuroconv.info import announcer
 
-neuroconv_api = Namespace("neuroconv", description="Neuroconv neuroconv_api for the NWB GUIDE.")
+neuroconv_api = Namespace(name="neuroconv", description="Neuroconv neuroconv_api for the NWB GUIDE.")
 
 parser = reqparse.RequestParser()
-parser.add_argument("interfaces", type=str, action="split", help="Interfaces cannot be converted")
+parser.add_argument("interfaces", type=str, action="split", help="Interfaces cannot be converted.")
 
 
 @neuroconv_api.errorhandler(Exception)
-def exception_handler(error):
-    exceptiondata = traceback.format_exception(type(error), error, error.__traceback__)
-    return {"message": exceptiondata[-1], "traceback": "".join(exceptiondata)}
+def exception_handler(error: Exception) -> Dict[str, str]:
+    full_traceback = traceback.format_exception(type(error), error, error.__traceback__)
+    message = full_traceback[-1]
+    remaining_traceback = "".join(full_traceback[:-1])
+    return {"message": message, "traceback": remaining_traceback}
 
 
 @neuroconv_api.route("/")
diff --git a/src/pyflask/apis/neurosift.py b/src/pyflask/apis/neurosift.py
new file mode 100644
index 000000000..e43f89746
--- /dev/null
+++ b/src/pyflask/apis/neurosift.py
@@ -0,0 +1,68 @@
+"""An API for handling file system communication with the standalone Neurosift preview page."""
+
+import collections
+from typing import Union
+
+import flask
+import flask_restx
+
+from .utils import (
+    abort_if_not_nwb_file,
+    catch_exception_and_abort,
+    server_error_responses,
+)
+
+neurosift_api = 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)
+
+
+@neurosift_api.route(rule="/files/<path:file_path>")
+@neurosift_api.doc(
+    description="Handle adding and fetching NWB files from the global file registry.",
+)
+class NeurosiftFileManager(flask_restx.Resource):
+
+    @neurosift_api.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.",
+        responses=server_error_responses(codes=[200, 400, 500]),
+    )
+    @catch_exception_and_abort(api=neurosift_api, code=500)
+    def get(self, file_path: str) -> Union[flask.Response, None]:
+        abort_if_not_nwb_file(file_path=file_path, api=neurosift_api)
+        if 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 = unquote(file_path)
+
+        # Check if the file path is relative
+        is_file_relative = not 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_api.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",
+        responses=server_error_responses(codes=[200, 400, 500]),
+    )
+    @catch_exception_and_abort(api=neurosift_api, code=500)
+    def post(self, file_path: str) -> Union[str, None]:
+        abort_if_not_nwb_file(file_path=file_path, api=neurosift_api)
+
+        neurosift_file_registry[file_path] = True
+
+        return request.base_url
diff --git a/src/pyflask/apis/startup.py b/src/pyflask/apis/startup.py
index 823dbee00..c2ec8ab88 100644
--- a/src/pyflask/apis/startup.py
+++ b/src/pyflask/apis/startup.py
@@ -2,7 +2,7 @@
 
 from flask_restx import Namespace, Resource
 
-startup_api = Namespace("startup", description="API for startup commands related to the NWB GUIDE.")
+startup_api = Namespace(name="startup", description="API for startup commands related to the NWB GUIDE.")
 
 parser = startup_api.parser()
 parser.add_argument(
diff --git a/src/pyflask/apis/system.py b/src/pyflask/apis/system.py
new file mode 100644
index 000000000..d384362d9
--- /dev/null
+++ b/src/pyflask/apis/system.py
@@ -0,0 +1,26 @@
+"""An API for handling general system information."""
+
+from typing import Dict, Union
+
+import flask_restx
+
+from .utils import catch_exception_and_abort, server_error_responses
+
+system_api = flask_restx.Namespace(name="system", description="Request various system specific information.")
+
+
+@system_api.route("/cpus")
+class SupportedSpecies(flask_restx.Resource):
+
+    @system_api.doc(
+        description="Request the number of physical and logical cores on the system.",
+        responses=server_error_responses(codes=[200, 500]),
+    )
+    @catch_exception_and_abort(api=system_api, code=500)
+    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/app.py b/src/pyflask/app.py
index 9929ce625..25774027f 100644
--- a/src/pyflask/app.py
+++ b/src/pyflask/app.py
@@ -2,12 +2,11 @@
 
 import json
 import multiprocessing
+import os
 import sys
 from datetime import datetime
 from logging import DEBUG, Formatter
 from logging.handlers import RotatingFileHandler
-from os import getpid, kill
-from os.path import isabs
 from pathlib import Path
 from signal import SIGINT
 from urllib.parse import unquote
@@ -15,131 +14,92 @@
 # 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
+import flask
+from apis import (
+    dandi_api,
+    data_api,
+    neuroconv_api,
+    neurosift_api,
+    startup_api,
+    system_api,
+)
+from apis.utils import catch_exception_and_abort, server_error_responses
+from flask import Flask
 from flask_cors import CORS
 from flask_restx import Api, Resource
-from manageNeuroconv.info import (
-    CONVERSION_SAVE_FOLDER_PATH,
-    GUIDE_ROOT_FOLDER,
-    STUB_SAVE_FOLDER_PATH,
-    is_packaged,
-    resource_path,
-)
+from manageNeuroconv.info import GUIDE_ROOT_FOLDER, get_project_root_path
+
+all_apis = [data_api, neuroconv_api, startup_api, neurosift_api, dandi_api, system_api]
 
-app = Flask(__name__)
+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")
+LOG_FOLDER = Path(GUIDE_ROOT_FOLDER) / "logs"
 LOG_FOLDER.mkdir(exist_ok=True, parents=True)
 timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
-LOG_FILE_PATH = Path(LOG_FOLDER, f"{timestamp}.log")
+LOG_FILE_PATH = Path(LOG_FOLDER) / f"{timestamp}.log"
 
-# Initialize API
-package_json_file_path = resource_path("package.json" if is_packaged() else "../package.json")
-with open(file=package_json_file_path) as fp:
+# Fetch version from package.json
+package_json_file_path = get_project_root_path() / "package.json"
+with open(file=package_json_file_path, mode="r") as fp:
     package_json = json.load(fp=fp)
 
-api = Api(
+# Initialize top-level API and set namespaces
+flask_api = Api(
     version=package_json["version"],
     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)
-
-registered = {}
-
-
-@app.route("/files")
-def get_all_files():
-    return list(registered.keys())
-
-
-@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)
-        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)
+for api in all_apis:
+    flask_api.add_namespace(api)
+flask_api.init_app(flask_app)
 
 
-@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
-
-    return species_map
-
-
-@api.route("/log")
+@flask_api.route(rule="/log")
+@flask_api.doc(
+    description="Any exception that occurs on the Flask server will save a full traceback to a log file on disk.",
+    responses=server_error_responses(codes=[200, 400, 500]),
+)
 class Log(Resource):
-    @api.doc(responses={200: "Success", 400: "Bad Request", 500: "Internal server error"})
+    @flask_api.doc(
+        description="Nicely format the exception and the payload that caused it.",
+        responses=server_error_responses(codes=[200, 400, 404, 500]),
+    )
+    @catch_exception_and_abort(api=flask_api, code=500)
     def post(self):
-        try:
+        payload = flask_api.payload
+        type = payload["type"]
+        header = payload["header"]
+        inputs = payload["inputs"]
+        exception_traceback = payload["traceback"]
 
-            payload = api.payload
-            type = payload["type"]
-            header = payload["header"]
-            inputs = payload["inputs"]
-            traceback = payload["traceback"]
+        message = f"{header}\n{'-'*len(header)}\n\n{json.dumps(inputs, indent=2)}\n\n{exception_traceback}\n"
+        selected_logger = getattr(flask_api.logger, type)
+        selected_logger(message)
 
-            message = f"{header}\n{'-'*len(header)}\n\n{json.dumps(inputs, indent=2)}\n\n{traceback}\n"
-            selected_logger = getattr(api.logger, type)
-            selected_logger(message)
 
-        except Exception as exception:
-            api.abort(500, str(exception))
+@flask_api.route("/server_shutdown", endpoint="shutdown")
+@flask_api.doc(description="Close the Flask server.")
+class Shutdown(Resource):
 
+    @flask_api.doc(
+        description="To trigger a shutdown, set a GET request to this endpoint. It will not return a response.",
+        responses=server_error_responses(codes=[200, 500]),
+    )
+    def get(self) -> None:
+        werkzeug_shutdown_function = flask.request.environ.get("werkzeug.server.shutdown")
+        flask_api.logger.info("Shutting down server...")
 
-@api.route("/server_shutdown", endpoint="shutdown")
-class Shutdown(Resource):
-    def get(self):
-        func = request.environ.get("werkzeug.server.shutdown")
-        api.logger.info("Shutting down server")
+        if werkzeug_shutdown_function is None:
+            os.kill(os.getpid(), SIGINT)
 
-        if func is None:
-            kill(getpid(), SIGINT)
             return
 
-        func()
+        werkzeug_shutdown_function()
 
 
 if __name__ == "__main__":
@@ -154,13 +114,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_api.logger.info(f"Starting server on 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/manageNeuroconv/info/__init__.py b/src/pyflask/manageNeuroconv/info/__init__.py
index 3a29439d2..fdf5a36ba 100644
--- a/src/pyflask/manageNeuroconv/info/__init__.py
+++ b/src/pyflask/manageNeuroconv/info/__init__.py
@@ -3,6 +3,6 @@
     CONVERSION_SAVE_FOLDER_PATH,
     GUIDE_ROOT_FOLDER,
     STUB_SAVE_FOLDER_PATH,
-    is_packaged,
-    resource_path,
+    get_project_root_path,
+    get_source_base_path,
 )
diff --git a/src/pyflask/manageNeuroconv/info/urls.py b/src/pyflask/manageNeuroconv/info/urls.py
index d41355b1f..aa296b73f 100644
--- a/src/pyflask/manageNeuroconv/info/urls.py
+++ b/src/pyflask/manageNeuroconv/info/urls.py
@@ -1,47 +1,48 @@
 import json
 import os
+import pathlib
 import sys
-from pathlib import Path
 
 
-def is_packaged():
-    deployed = True
-    try:
-        sys._MEIPASS  # PyInstaller creates a temp folder and stores path in _MEIPASS
-    except Exception:
-        deployed = False
+def get_source_base_path() -> pathlib.Path:
+    """Get absolute path of a relative resource to the app; works for both dev mode and for PyInstaller."""
+    # Production: PyInstaller creates a temp folder at runtime and stores path in _MEIPASS
+    if hasattr(sys, "_MEIPASS"):
+        base_path = pathlib.Path(sys._MEIPASS)
 
-    return deployed
+    # Dev mode: base is the root of the `src` directory for the project
+    else:
+        base_path = pathlib.Path(__file__).parent.parent.parent.parent
 
+    return base_path
 
-def resource_path(relative_path):
-    """Get absolute path to resource, works for dev and for PyInstaller"""
-    try:
-        # PyInstaller creates a temp folder and stores path in _MEIPASS
-        base_path = sys._MEIPASS
-    except Exception:
-        base_path = Path(__file__).parent.parent.parent.parent
 
-    return Path(base_path) / relative_path
+def get_project_root_path() -> pathlib.Path:
+    """Get absolute path of a relative resource to the app; works for both dev mode and for PyInstaller."""
+    # Production: PyInstaller creates a temp folder at runtime and stores path in _MEIPASS
+    if hasattr(sys, "_MEIPASS"):
+        base_path = pathlib.Path(sys._MEIPASS).parent
+
+    # Dev mode: root of project is one level above root of `src`
+    else:
+        base_path = pathlib.Path(__file__).parent.parent.parent.parent.parent
+
+    return base_path
 
 
 is_test_environment = os.environ.get("VITEST")
 
-path_config = resource_path(
-    "paths.config.json"
-)  # NOTE: Must have pyflask for running the GUIDE as a whole, but errors for just the server
 
-f = path_config.open()
-data = json.load(f)
-GUIDE_ROOT_FOLDER = Path(Path.home(), data["root"])
+path_config_file_path = get_source_base_path() / "paths.config.json"
+with open(file=path_config_file_path, mode="r") as fp:
+    path_config = json.load(fp=fp)
+GUIDE_ROOT_FOLDER = pathlib.Path.home() / path_config["root"]
 
 if is_test_environment:
     GUIDE_ROOT_FOLDER = GUIDE_ROOT_FOLDER / ".test"
 
-STUB_SAVE_FOLDER_PATH = Path(GUIDE_ROOT_FOLDER, *data["subfolders"]["preview"])
-CONVERSION_SAVE_FOLDER_PATH = Path(GUIDE_ROOT_FOLDER, *data["subfolders"]["conversions"])
-
-f.close()
+STUB_SAVE_FOLDER_PATH = pathlib.Path(GUIDE_ROOT_FOLDER, *path_config["subfolders"]["preview"])
+CONVERSION_SAVE_FOLDER_PATH = pathlib.Path(GUIDE_ROOT_FOLDER, *path_config["subfolders"]["conversions"])
 
 # Create all nested home folders
 STUB_SAVE_FOLDER_PATH.mkdir(exist_ok=True, parents=True)
diff --git a/src/pyflask/tests/conftest.py b/src/pyflask/tests/conftest.py
index ec72c792b..c6f863924 100644
--- a/src/pyflask/tests/conftest.py
+++ b/src/pyflask/tests/conftest.py
@@ -3,7 +3,7 @@
 
 
 def pytest_addoption(parser):
-    parser.addoption("--target", action="store", help="Run the executable instead of the standard Flask app")
+    parser.addoption("--target", action="store", help="Run the executable instead of the standard Flask app.")
 
 
 @pytest.fixture(scope="session")
diff --git a/src/schemas/interfaces.info.ts b/src/schemas/interfaces.info.ts
index 7ecc13cc7..e52e671ad 100644
--- a/src/schemas/interfaces.info.ts
+++ b/src/schemas/interfaces.info.ts
@@ -13,7 +13,7 @@ export const ready = {
     interfaces: createPromise("interfaces"),
 }
 
-//  Get CPUs
+//  Fetch data formats
 onServerOpen(async () => {
     await fetch(`${baseUrl}/neuroconv`).then((res) => res.json())
     .then((interfaces) => setReady.interfaces(interfaces))