diff --git a/Makefile b/Makefile
index 843e4e1..a1460f3 100644
--- a/Makefile
+++ b/Makefile
@@ -25,7 +25,7 @@ MPY_TARGETS = $(patsubst $(SRC_DIR)/%.py,$(BUILD_DIR)/%.mpy,$(NON_INIT_PY))
 INIT_TARGETS = $(patsubst $(SRC_DIR)/%.py,$(BUILD_DIR)/%.py,$(filter %__init__.py,$(PY_FILES)))
 
 .PHONY: all
-all: clean toolchain static-checkers unit-test build test-unix deploy publish
+all: clean toolchain static-checkers unit-test build test-unix deploy deploy-config tls-cert deploy-cert deploy-example
 
 # ================================================
 # Build
@@ -179,7 +179,7 @@ run-unix: stage-example
 # -----------------------------
 .PHONY: deploy-example
 deploy-example:
-	@echo "Uploading boot.py"
+	@echo "Uploading boot.py, app.py"
 	@mpremote $(DEVICE) soft-reset
 	mpremote $(DEVICE) cp $(EXAMPLE_DIR)/boot.py :boot.py
 	mpremote $(DEVICE) cp $(EXAMPLE_DIR)/app.py :app.py
@@ -187,14 +187,15 @@ deploy-example:
 	@echo "Uploading pyrobusta.env"
 	@if [ -f pyrobusta.env ]; then mpremote $(DEVICE) cp pyrobusta.env :pyrobusta.env; fi
 	@mpremote $(DEVICE) reset
+	@echo "\e[32m$(EXAMPLE_DIR) example is successfully deployed, \n"\
+	"run 'make DEVICE=$(DEVICE) run-device' to restart the device and check the output.\e[0m"
 
 # -----------------------------
-# Run example directly
+# Connect to device through REPL
 # -----------------------------
 .PHONY: run-device
 run-device:
-	@mpremote $(DEVICE) soft-reset
-	mpremote $(DEVICE) run $(EXAMPLE_DIR)/app.py
+	@mpremote $(DEVICE) reset repl
 
 
 # ================================================
diff --git a/README.md b/README.md
index 0a14064..3acb293 100644
--- a/README.md
+++ b/README.md
@@ -60,8 +60,8 @@ make build              # Cross-compile, create build artifacts
 make deploy             # Upload build artifacts to device using mpremote
 make tls-cert           # Optional: generate self-signed certificate for the device
 make deploy-cert        # Optional: upload generated certificate to the device
-make deploy-example     # Upload example application using mpremote
-make run-device         # Run application on the device using mpremote run
+make deploy-example     # Deploy the selected example app using mpremote
+make run-device         # Optional: Reset the device and connect through REPL
 ```
 ```deploy-example``` and ```run-device``` uses the DEVICE argument
 set to ```u0``` (/dev/ttyUSB0) by default, passed to mpremote.
diff --git a/assets/www/examples.html b/assets/www/examples.html
index 7c6cbef..bce9539 100644
--- a/assets/www/examples.html
+++ b/assets/www/examples.html
@@ -103,14 +103,14 @@ <h2>Simple Server Application</h2>
         logging.warning(f"loop stopped: {e}")
         asyncio.get_event_loop().close()
     </textarea>
-    <textarea readonly="true" rows="13">
+    <textarea readonly="true" rows="15">
 # /boot.py
 
 # This file is executed on every boot (including wake-boot from deepsleep)
 import machine
 from os import listdir
 
-from pyrobusta.con import wifi
+from pyrobusta.connectivity import wifi
 
 connected = wifi.initialize()
 if connected and not machine.reset_cause() == machine.SOFT_RESET:
diff --git a/dist/pyrobusta/assets/www/examples.html b/dist/pyrobusta/assets/www/examples.html
index 095c675..e41ce6b 100644
--- a/dist/pyrobusta/assets/www/examples.html
+++ b/dist/pyrobusta/assets/www/examples.html
@@ -108,7 +108,7 @@ <h2>Simple Server Application</h2>
 import machine
 from os import listdir
 
-from pyrobusta.con import wifi
+from pyrobusta.connectivity import wifi
 
 connected = wifi.initialize()
 if connected and not machine.reset_cause() == machine.SOFT_RESET:
diff --git a/docs/dimensioning/http_dimensioning.md b/docs/dimensioning/http_dimensioning.md
new file mode 100644
index 0000000..e2a91bd
--- /dev/null
+++ b/docs/dimensioning/http_dimensioning.md
@@ -0,0 +1,71 @@
+Use the following measurement data to guide configuration choices when dimensioning the\
+HTTP server for specific constraints such as memory footprint, request throughput, and\
+feature enablement (e.g., TLS, multipart handling, file serving).
+
+The tables below are derived from controlled benchmarks. Each measurement varies a subset\
+of parameters relative to a defined baseline configuration.
+
+```.env
+# Base configuration
+socket_max_con=1
+http_mem_cap=0.05
+http_multipart=False
+http_serve_files=True
+tls=False
+http_port=8080
+https_port=4443
+log_level=info
+http_served_paths=/lib/pyrobusta /www
+```
+
+# ESP32-C3 "SuperMini" (ESP32-C3FH4)
+The ESP32-C3 provides approximately 162KB of usable heap. It is recommended to limit the maximum\
+number of socket connections to 2 (socket_max_con).
+
+## Idle heap usage
+The table below reports heap consumption after module imports, measured under idle conditions\
+with no active network traffic.
+
+| id | http_mem_cap | http_multipart | socket_max_con | tls | footprint_bytes |
+| --- | --- | --- | --- | --- | --- |
+| base | 0.05 | False | 1 | False | 38448 |
+| low_mem_cap_001 | 0.0127 | False | 1 | False | 38448 |
+| low_mem_cap_002 | 0.0253 | False | 2 | False | 39664 |
+| low_mem_cap_003 | 0.0505 | False | 4 | False | 42096 |
+| high_mem_cap_001 | 0.0568 | False | 1 | False | 45616 |
+| high_mem_cap_002 | 0.114 | False | 2 | False | 54000 |
+| high_mem_cap_003 | 0.228 | False | 4 | False | 70768 |
+| multipart_001 | 0.0127 | True | 1 | False | 40704 |
+| multipart_002 | 0.0253 | True | 2 | False | 41920 |
+| multipart_003 | 0.0505 | True | 4 | False | 44352 |
+| tls_001 | 0.0127 | False | 1 | True | 41120 |
+| tls_002 | 0.0253 | False | 2 | True | 42336 |
+| tls_003 | 0.0505 | False | 4 | True | 44768 |
+
+## Heap usage under network traffic
+![image info](./img/esp32_c3/base.png)
+
+
+# ESP32-S3 (8MB PSRAM)
+The table below reports heap consumption after module imports, measured under idle conditions\
+with no active network traffic.
+
+## Idle heap usage
+| id | http_mem_cap | http_multipart | socket_max_con | tls | footprint_bytes |
+| --- | --- | --- | --- | --- | --- |
+| base | 0.05 | False | 1 | False | 45520 |
+| low_mem_cap_001 | 0.000247 | False | 1 | False | 38352 |
+| low_mem_cap_002 | 0.000493 | False | 2 | False | 39568 |
+| low_mem_cap_003 | 0.000985 | False | 4 | False | 42000 |
+| high_mem_cap_001 | 0.00111 | False | 1 | False | 45520 |
+| high_mem_cap_002 | 0.00222 | False | 2 | False | 53904 |
+| high_mem_cap_003 | 0.00443 | False | 4 | False | 70672 |
+| multipart_001 | 0.000247 | True | 1 | False | 40656 |
+| multipart_002 | 0.000493 | True | 2 | False | 41872 |
+| multipart_003 | 0.000985 | True | 4 | False | 44304 |
+| tls_001 | 0.000247 | False | 1 | True | 40736 |
+| tls_002 | 0.000493 | False | 2 | True | 41952 |
+| tls_003 | 0.000985 | False | 4 | True | 44384 |
+
+## Heap usage under network traffic
+![image info](./img/esp32_s3/base.png)
\ No newline at end of file
diff --git a/docs/dimensioning/img/esp32_c3/base.png b/docs/dimensioning/img/esp32_c3/base.png
new file mode 100644
index 0000000..75fa126
Binary files /dev/null and b/docs/dimensioning/img/esp32_c3/base.png differ
diff --git a/docs/dimensioning/img/esp32_c3/high_mem_cap_001.png b/docs/dimensioning/img/esp32_c3/high_mem_cap_001.png
new file mode 100644
index 0000000..9ae01ff
Binary files /dev/null and b/docs/dimensioning/img/esp32_c3/high_mem_cap_001.png differ
diff --git a/docs/dimensioning/img/esp32_c3/high_mem_cap_002.png b/docs/dimensioning/img/esp32_c3/high_mem_cap_002.png
new file mode 100644
index 0000000..e0af9fa
Binary files /dev/null and b/docs/dimensioning/img/esp32_c3/high_mem_cap_002.png differ
diff --git a/docs/dimensioning/img/esp32_c3/high_mem_cap_003.png b/docs/dimensioning/img/esp32_c3/high_mem_cap_003.png
new file mode 100644
index 0000000..a666ee7
Binary files /dev/null and b/docs/dimensioning/img/esp32_c3/high_mem_cap_003.png differ
diff --git a/docs/dimensioning/img/esp32_c3/low_mem_cap_001.png b/docs/dimensioning/img/esp32_c3/low_mem_cap_001.png
new file mode 100644
index 0000000..a9285ae
Binary files /dev/null and b/docs/dimensioning/img/esp32_c3/low_mem_cap_001.png differ
diff --git a/docs/dimensioning/img/esp32_c3/low_mem_cap_002.png b/docs/dimensioning/img/esp32_c3/low_mem_cap_002.png
new file mode 100644
index 0000000..35fbf73
Binary files /dev/null and b/docs/dimensioning/img/esp32_c3/low_mem_cap_002.png differ
diff --git a/docs/dimensioning/img/esp32_c3/low_mem_cap_003.png b/docs/dimensioning/img/esp32_c3/low_mem_cap_003.png
new file mode 100644
index 0000000..1c58314
Binary files /dev/null and b/docs/dimensioning/img/esp32_c3/low_mem_cap_003.png differ
diff --git a/docs/dimensioning/img/esp32_c3/multipart_001.png b/docs/dimensioning/img/esp32_c3/multipart_001.png
new file mode 100644
index 0000000..08e0f1a
Binary files /dev/null and b/docs/dimensioning/img/esp32_c3/multipart_001.png differ
diff --git a/docs/dimensioning/img/esp32_c3/multipart_002.png b/docs/dimensioning/img/esp32_c3/multipart_002.png
new file mode 100644
index 0000000..fd54765
Binary files /dev/null and b/docs/dimensioning/img/esp32_c3/multipart_002.png differ
diff --git a/docs/dimensioning/img/esp32_c3/multipart_003.png b/docs/dimensioning/img/esp32_c3/multipart_003.png
new file mode 100644
index 0000000..046c0a3
Binary files /dev/null and b/docs/dimensioning/img/esp32_c3/multipart_003.png differ
diff --git a/docs/dimensioning/img/esp32_c3/tls_001.png b/docs/dimensioning/img/esp32_c3/tls_001.png
new file mode 100644
index 0000000..9d933c0
Binary files /dev/null and b/docs/dimensioning/img/esp32_c3/tls_001.png differ
diff --git a/docs/dimensioning/img/esp32_c3/tls_002.png b/docs/dimensioning/img/esp32_c3/tls_002.png
new file mode 100644
index 0000000..a69e17d
Binary files /dev/null and b/docs/dimensioning/img/esp32_c3/tls_002.png differ
diff --git a/docs/dimensioning/img/esp32_c3/tls_003.png b/docs/dimensioning/img/esp32_c3/tls_003.png
new file mode 100644
index 0000000..5c6b128
Binary files /dev/null and b/docs/dimensioning/img/esp32_c3/tls_003.png differ
diff --git a/docs/dimensioning/img/esp32_s3/base.png b/docs/dimensioning/img/esp32_s3/base.png
new file mode 100644
index 0000000..b814774
Binary files /dev/null and b/docs/dimensioning/img/esp32_s3/base.png differ
diff --git a/docs/dimensioning/img/esp32_s3/high_mem_cap_001.png b/docs/dimensioning/img/esp32_s3/high_mem_cap_001.png
new file mode 100644
index 0000000..81887d2
Binary files /dev/null and b/docs/dimensioning/img/esp32_s3/high_mem_cap_001.png differ
diff --git a/docs/dimensioning/img/esp32_s3/high_mem_cap_002.png b/docs/dimensioning/img/esp32_s3/high_mem_cap_002.png
new file mode 100644
index 0000000..664932a
Binary files /dev/null and b/docs/dimensioning/img/esp32_s3/high_mem_cap_002.png differ
diff --git a/docs/dimensioning/img/esp32_s3/high_mem_cap_003.png b/docs/dimensioning/img/esp32_s3/high_mem_cap_003.png
new file mode 100644
index 0000000..c81a08a
Binary files /dev/null and b/docs/dimensioning/img/esp32_s3/high_mem_cap_003.png differ
diff --git a/docs/dimensioning/img/esp32_s3/low_mem_cap_001.png b/docs/dimensioning/img/esp32_s3/low_mem_cap_001.png
new file mode 100644
index 0000000..fc48588
Binary files /dev/null and b/docs/dimensioning/img/esp32_s3/low_mem_cap_001.png differ
diff --git a/docs/dimensioning/img/esp32_s3/low_mem_cap_002.png b/docs/dimensioning/img/esp32_s3/low_mem_cap_002.png
new file mode 100644
index 0000000..45dd764
Binary files /dev/null and b/docs/dimensioning/img/esp32_s3/low_mem_cap_002.png differ
diff --git a/docs/dimensioning/img/esp32_s3/low_mem_cap_003.png b/docs/dimensioning/img/esp32_s3/low_mem_cap_003.png
new file mode 100644
index 0000000..a1f9643
Binary files /dev/null and b/docs/dimensioning/img/esp32_s3/low_mem_cap_003.png differ
diff --git a/docs/dimensioning/img/esp32_s3/multipart_001.png b/docs/dimensioning/img/esp32_s3/multipart_001.png
new file mode 100644
index 0000000..b3b9817
Binary files /dev/null and b/docs/dimensioning/img/esp32_s3/multipart_001.png differ
diff --git a/docs/dimensioning/img/esp32_s3/multipart_002.png b/docs/dimensioning/img/esp32_s3/multipart_002.png
new file mode 100644
index 0000000..6e04077
Binary files /dev/null and b/docs/dimensioning/img/esp32_s3/multipart_002.png differ
diff --git a/docs/dimensioning/img/esp32_s3/multipart_003.png b/docs/dimensioning/img/esp32_s3/multipart_003.png
new file mode 100644
index 0000000..a799ddc
Binary files /dev/null and b/docs/dimensioning/img/esp32_s3/multipart_003.png differ
diff --git a/docs/dimensioning/img/esp32_s3/tls_001.png b/docs/dimensioning/img/esp32_s3/tls_001.png
new file mode 100644
index 0000000..af9ea15
Binary files /dev/null and b/docs/dimensioning/img/esp32_s3/tls_001.png differ
diff --git a/docs/dimensioning/img/esp32_s3/tls_002.png b/docs/dimensioning/img/esp32_s3/tls_002.png
new file mode 100644
index 0000000..91aefdc
Binary files /dev/null and b/docs/dimensioning/img/esp32_s3/tls_002.png differ
diff --git a/docs/dimensioning/img/esp32_s3/tls_003.png b/docs/dimensioning/img/esp32_s3/tls_003.png
new file mode 100644
index 0000000..fb13661
Binary files /dev/null and b/docs/dimensioning/img/esp32_s3/tls_003.png differ
diff --git a/example/demo_app/app.py b/example/demo_app/app.py
index 4d2491b..28ba282 100644
--- a/example/demo_app/app.py
+++ b/example/demo_app/app.py
@@ -3,7 +3,6 @@
 
 from pyrobusta.server import http_server
 from pyrobusta.protocol.http import HttpEngine
-from pyrobusta.utils import logging
 
 
 @HttpEngine.route("/app", "GET")
@@ -24,10 +23,8 @@ def app(http_ctx, payload):
     return "text/plain", (f"Free memory [{value_format}]: {free}\n")
 
 
-def main():
-    http_server.main()
-    try:
-        asyncio.get_event_loop().run_forever()
-    except Exception as e:
-        logging.warning(f"loop stopped: {e}")
-        asyncio.get_event_loop().close()
+async def main():
+    server = http_server.HttpServer()
+    asyncio.create_task(server.start_socket_server())
+    while True:
+        await asyncio.sleep(1)
diff --git a/example/demo_app/boot.py b/example/demo_app/boot.py
index a7c9c58..e286346 100644
--- a/example/demo_app/boot.py
+++ b/example/demo_app/boot.py
@@ -1,12 +1,13 @@
 # This file is executed on every boot (including wake-boot from deepsleep)
+import asyncio
 import machine
 from os import listdir
 
-from pyrobusta.con import wifi
+from pyrobusta.connectivity import wifi
 
 connected = wifi.initialize()
 if connected and not machine.reset_cause() == machine.SOFT_RESET:
     if "app.py" in listdir():
         import app
 
-        app.main()
+        asyncio.run(app.main())
diff --git a/example/mem_usage/app.py b/example/mem_usage/app.py
index b3ac746..108fb5f 100644
--- a/example/mem_usage/app.py
+++ b/example/mem_usage/app.py
@@ -3,7 +3,6 @@
 
 import pyrobusta.server.http_server as http_server
 from pyrobusta.protocol.http import HttpEngine
-from pyrobusta.utils import logging
 
 
 @HttpEngine.route("/mem-usage", "GET")
@@ -23,11 +22,11 @@ def mem_usage(http_ctx, _):
         selector = http_ctx.get_url_encoded_query_param(http_ctx.query, "key", "")
         if selector == "free":
             if value_format == "%":
-                free = round(100 * free / (used + free),2)
+                free = round(100 * free / (used + free), 2)
             return "text/plain", f"Free   [{value_format}]: {free}\n"
         if selector == "used":
             if value_format == "%":
-                used = round(100 * used / (used + free),2)
+                used = round(100 * used / (used + free), 2)
             return "text/plain", f"Used   [{value_format}]: {used}\n"
         if selector == "total":
             return "text/plain", f"Total  [bytes]: {used + free}\n"
@@ -43,10 +42,8 @@ def mem_usage(http_ctx, _):
     )
 
 
-http_server.main()
-
-try:
-    asyncio.get_event_loop().run_forever()
-except Exception as e:
-    logging.warning(f"[asyncio] loop stopped: {e}")
-    asyncio.get_event_loop().close()
+async def main():
+    server = http_server.HttpServer()
+    asyncio.create_task(server.start_socket_server())
+    while True:
+        await asyncio.sleep(1)
diff --git a/example/mem_usage/boot.py b/example/mem_usage/boot.py
index a7c9c58..e286346 100644
--- a/example/mem_usage/boot.py
+++ b/example/mem_usage/boot.py
@@ -1,12 +1,13 @@
 # This file is executed on every boot (including wake-boot from deepsleep)
+import asyncio
 import machine
 from os import listdir
 
-from pyrobusta.con import wifi
+from pyrobusta.connectivity import wifi
 
 connected = wifi.initialize()
 if connected and not machine.reset_cause() == machine.SOFT_RESET:
     if "app.py" in listdir():
         import app
 
-        app.main()
+        asyncio.run(app.main())
diff --git a/example/mip_repo/app.py b/example/mip_repo/app.py
index 80f5625..421d9d5 100644
--- a/example/mip_repo/app.py
+++ b/example/mip_repo/app.py
@@ -1,5 +1,4 @@
 import asyncio
-import os
 
 import pyrobusta.server.http_server as http_server
 from pyrobusta.protocol.http import HttpEngine
@@ -42,10 +41,8 @@ def self_serve_mip_package(http_ctx, _):
     return "application/json", package_files
 
 
-http_server.main()
-
-try:
-    asyncio.get_event_loop().run_forever()
-except Exception as e:
-    logging.warning(f"[asyncio] loop stopped: {e}")
-    asyncio.get_event_loop().close()
+async def main():
+    server = http_server.HttpServer()
+    asyncio.create_task(server.start_socket_server())
+    while True:
+        await asyncio.sleep(1)
diff --git a/example/mip_repo/boot.py b/example/mip_repo/boot.py
index a7c9c58..e286346 100644
--- a/example/mip_repo/boot.py
+++ b/example/mip_repo/boot.py
@@ -1,12 +1,13 @@
 # This file is executed on every boot (including wake-boot from deepsleep)
+import asyncio
 import machine
 from os import listdir
 
-from pyrobusta.con import wifi
+from pyrobusta.connectivity import wifi
 
 connected = wifi.initialize()
 if connected and not machine.reset_cause() == machine.SOFT_RESET:
     if "app.py" in listdir():
         import app
 
-        app.main()
+        asyncio.run(app.main())
diff --git a/requirements.txt b/requirements.txt
index e596cc8..33b498a 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,3 +1,5 @@
 mpremote==1.27.0
 pylint
 black
+requests
+matplotlib
diff --git a/scripts/clean_device.py b/scripts/clean_device.py
index 9e97569..22d06ab 100644
--- a/scripts/clean_device.py
+++ b/scripts/clean_device.py
@@ -1,18 +1,28 @@
-import uos
+from os import listdir, remove, rmdir
 
 
-def delete_all(path):
-    try:
-        for name in uos.listdir(path):
+def delete_path(path):
+    for name in listdir(path):
+        if path == "/":
+            full = "/" + name
+        else:
             full = path + "/" + name
+
+        try:
+            remove(full)
+        except OSError:
+            delete_path(full)
             try:
-                uos.remove(full)
+                rmdir(full)
             except OSError:
-                delete_all(full)
-                uos.rmdir(full)
-        uos.rmdir(path)
-    except OSError:
-        pass
+                pass
 
 
-delete_all("/pyrobusta")
+delete_path("/lib/pyrobusta")
+delete_path("/www")
+
+for f in ("/app.py", "/boot.py", "/pyrobusta.env", "/cert.der", "/key.der"):
+    try:
+        remove(f)
+    except OSError:
+        pass
\ No newline at end of file
diff --git a/src/pyrobusta/bindings/socket_http.py b/src/pyrobusta/bindings/http_connection.py
similarity index 82%
rename from src/pyrobusta/bindings/socket_http.py
rename to src/pyrobusta/bindings/http_connection.py
index f646719..533dfc3 100644
--- a/src/pyrobusta/bindings/socket_http.py
+++ b/src/pyrobusta/bindings/http_connection.py
@@ -4,15 +4,14 @@
 
 import asyncio
 from asyncio import sleep_ms  # pylint: disable=E1101
-from gc import collect
 
 from ..stream.buffer import BufferFullError
-from ..transport.socket import SocketBase
+from ..transport.connection import BaseConnection
 from ..protocol.http import HttpEngine, ServerBusyError, HeaderParsingError
 from ..utils import logging
 
 
-class SocketHttp(SocketBase):
+class HttpConnection(BaseConnection):
     """
     HTTP wrapper class for representing HTTP socket connections, with
     buffer management and state machine parser.
@@ -32,25 +31,20 @@ def __init__(self, reader, writer, recv_buf, send_buf):
         self._recv_buf = recv_buf
         self._send_buf = send_buf
 
-    async def _flush_response(self):
-        data = self._send_buf.peek()
-        for i in range(0, len(data), SocketHttp.MTU_SIZE):
-            self.writer.write(data[i : i + SocketHttp.MTU_SIZE])
-            await self.writer.drain()
-        self._send_buf.consume()
-
     async def run(self):
         """
         Handle socket connection with HTTP state machine parser.
         """
         self._prev_state = None
-        try:
-            while self._engine.state is not None:
-                await self._run_state_machine()
-                await sleep_ms(SocketHttp.STATE_MACHINE_SLEEP_MS)
-        finally:
-            await self.close()
-            collect()
+        while self._engine.state is not None:
+            await self._run_state_machine()
+            await sleep_ms(self.STATE_MACHINE_SLEEP_MS)
+
+    async def _flush_response(self):
+        data = self._send_buf.peek()
+        for i in range(0, len(data), self.MTU_SIZE):
+            await self.write(data[i : i + self.MTU_SIZE])
+        self._send_buf.consume()
 
     async def _read_to_buf(self):
         buf_free = self._recv_buf.capacity - self._recv_buf.size()
@@ -62,7 +56,7 @@ async def _read_to_buf(self):
             request = await self.read(
                 read_bytes=buf_free,
                 decoding=None,
-                timeout_seconds=SocketHttp.RECV_TIMEOUT_SECONDS,
+                timeout_seconds=self.RECV_TIMEOUT_SECONDS,
             )
         except asyncio.TimeoutError:
             self._engine.on_timeout(self._send_buf)
@@ -82,6 +76,11 @@ async def _run_state_machine(self):
         if self._prev_state == self._engine.state or self._prev_state is None:
             num_read = await self._read_to_buf()
             if not num_read:
+                # Reject incomplete request
+                self._engine.on_client_error(
+                    self._send_buf, self._engine.BAD_REQUEST_ERROR
+                )
+                await self._flush_response()
                 return
         try:
             resp_handler = None
@@ -91,7 +90,7 @@ async def _run_state_machine(self):
                 if not self._send_buf.size():
                     break
                 await self._flush_response()
-                await sleep_ms(SocketHttp.STATE_MACHINE_SLEEP_MS)
+                await sleep_ms(self.STATE_MACHINE_SLEEP_MS)
         except BufferFullError:
             self._engine.on_failure(self._send_buf, b"Buffer full")
             await self._flush_response()
@@ -101,7 +100,7 @@ async def _run_state_machine(self):
             await self._flush_response()
             return
         except HeaderParsingError:
-            self._engine.on_client_error(self._send_buf, b"Invalid headers")
+            self._engine.on_client_error(self._send_buf, self._engine.HEADER_ERROR)
             await self._flush_response()
             return
         except Exception as e:  # pylint: disable=W0718
@@ -118,7 +117,7 @@ async def _response_handler(self, resp_handler):
                 await self._flush_response()
                 if is_finished:
                     break
-                await sleep_ms(SocketHttp.RESP_HANDLER_SLEEP_MS)
+                await sleep_ms(self.RESP_HANDLER_SLEEP_MS)
         elif type(resp_handler).__name__ in ("FileIO", "BytesIO"):
             with resp_handler as rh:
                 while True:
@@ -128,7 +127,7 @@ async def _response_handler(self, resp_handler):
                         break
                     self._send_buf.commit(num_read)
                     await self._flush_response()
-                    await sleep_ms(SocketHttp.RESP_HANDLER_SLEEP_MS)
+                    await sleep_ms(self.RESP_HANDLER_SLEEP_MS)
         else:
             self._engine.on_failure(
                 self._send_buf,
diff --git a/src/pyrobusta/con/__init__.py b/src/pyrobusta/connectivity/__init__.py
similarity index 100%
rename from src/pyrobusta/con/__init__.py
rename to src/pyrobusta/connectivity/__init__.py
diff --git a/src/pyrobusta/con/wifi.py b/src/pyrobusta/connectivity/wifi.py
similarity index 100%
rename from src/pyrobusta/con/wifi.py
rename to src/pyrobusta/connectivity/wifi.py
diff --git a/src/pyrobusta/server/http_server.py b/src/pyrobusta/server/http_server.py
index 6b9a1c3..6e7d4d5 100644
--- a/src/pyrobusta/server/http_server.py
+++ b/src/pyrobusta/server/http_server.py
@@ -2,12 +2,12 @@
 Socket server application
 """
 
-from gc import collect, mem_free
-from asyncio import sleep_ms, start_server, run  # pylint: disable=E1101
+from gc import collect, mem_free, mem_alloc
+from asyncio import sleep_ms, start_server  # pylint: disable=E1101
 from time import ticks_ms, ticks_diff
 
 from ..protocol import http
-from ..bindings.socket_http import SocketHttp
+from ..bindings.http_connection import HttpConnection
 from ..stream.buffer import MemoryPool, SlidingBuffer
 from ..utils.config import (
     get_config,
@@ -67,7 +67,7 @@ def _init_pools(cls, max_clients):
         """
         Initialize pool of buffers for sending/receiving based on different profiles
         """
-        mem_available = mem_free()
+        mem_available = mem_free() + mem_alloc()
         con_limit = max_clients
         usable = int(cls.MEM_CAP * mem_available)
         is_low_memory = (usable / con_limit) < (
@@ -101,8 +101,6 @@ async def _drop_client(cls, client):
         logging.debug(__name__ + f": {client.id} dropped")
         await client.close()
         cls.ACTIVE_CLIENTS.remove(client)
-        del client
-        collect()
 
     # ----------------
     # Instance methods
@@ -124,7 +122,6 @@ async def can_handle_new_client(self):
         Evict closed/inactive sockets if needed.
         :return is_acceptable: true/false
         """
-        collect()
         con_timestamp = ticks_ms()
         while ticks_diff(ticks_ms(), con_timestamp) < self.CON_ACCEPT_TIMEOUT_MS:
             if len(self.ACTIVE_CLIENTS) < self._max_clients:
@@ -162,7 +159,7 @@ async def _reserve_buffers(self):
     async def _accept_socket(self, reader, writer):
         """
         Handle incoming socket connection for HTTP.
-        - creates SocketHttp object
+        - creates HttpConnection object
         """
         if not await self.can_handle_new_client():
             logging.debug(__name__ + ": cannot accept new client")
@@ -170,15 +167,19 @@ async def _accept_socket(self, reader, writer):
             await writer.wait_closed()
             return
 
+        client = None
         try:
             recv_buf, send_buf = await self._reserve_buffers()
-            new_client = SocketHttp(reader, writer, recv_buf, send_buf)
-            logging.debug(__name__ + f": accept {new_client.id}")
-            self.ACTIVE_CLIENTS.append(new_client)
-            await new_client.run()
+            client = HttpConnection(reader, writer, recv_buf, send_buf)
+            logging.debug(__name__ + f": accept {client.id}")
+            self.ACTIVE_CLIENTS.append(client)
+            async with client:
+                await client.run()
         except Exception as e:  # pylint: disable=W0718
             logging.warning(__name__ + f": error in run(): {e}")
         finally:
+            if client:
+                self.ACTIVE_CLIENTS.remove(client)
             if send_buf:
                 send_buf.consume()
                 self.SEND_POOL.release(send_buf)
@@ -233,10 +234,3 @@ async def terminate(self):
             await self._server.wait_closed()
             self._server = None
         collect()
-
-
-def main():
-    """
-    Start HTTP server async task.
-    """
-    run(HttpServer().start_socket_server())
diff --git a/src/pyrobusta/transport/connection.py b/src/pyrobusta/transport/connection.py
new file mode 100644
index 0000000..ce516e4
--- /dev/null
+++ b/src/pyrobusta/transport/connection.py
@@ -0,0 +1,89 @@
+"""
+Base class for representing a socket, providing common methods
+and member variables for the socket server to use.
+"""
+
+import asyncio
+from time import ticks_ms
+
+from ..utils import logging
+
+
+class BaseConnection:
+    """
+    BaseConnection class, accepting a StreamReader and StreamWriter.
+    """
+
+    __slots__ = ("id", "connected", "last_event", "_reader", "_writer")
+
+    def __init__(self, reader, writer):
+        """
+        Base class for connection handling.
+        :param reader: async reader stream object
+        :param writer: async writer stream object
+        """
+        client_info = writer.get_extra_info("peername")
+        self.id = str(client_info[0]) + ":" + str(client_info[1])
+        self.connected = True
+        self.last_event = ticks_ms()
+        self._reader = reader
+        self._writer = writer
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_value, traceback):
+        await self.close()
+
+    async def read(
+        self, read_bytes: int, decoding: str = "utf8", timeout_seconds: int = 0
+    ):
+        """
+        Read data with StreamReader object, wraps the read() method of StreamReader.
+        :param read_bytes: number of bytes to read
+        :param decoding: decoding to use (optional), bytes are returned by default
+        :param timeout_seconds: an exception is raised if exceeded, 0 means waiting indefinitely
+        :return data: holds bytes or decoded string read from the socket
+        """
+        if not self.connected:
+            raise OSError(f"{self.id} already closed")
+
+        logging.debug(__name__ + f": read from {self.id}")
+        self.last_event = ticks_ms()
+        if timeout_seconds:
+            request = await asyncio.wait_for(
+                self._reader.read(read_bytes), timeout_seconds
+            )
+        else:
+            request = await self._reader.read(read_bytes)
+        if decoding:
+            request = request.decode(decoding)
+        return request
+
+    async def write(self, data: bytes | bytearray | memoryview):
+        """
+        Write data with StreamWriter object, wraps the write() method of StreamWriter.
+        :param data: data to writes
+        """
+        if not self.connected:
+            raise OSError(f"{self.id} already closed")
+
+        logging.debug(__name__ + f": write to {self.id}")
+        self._writer.write(data)
+        await self._writer.drain()
+        self.last_event = ticks_ms()
+
+    async def close(self):
+        """
+        Close the connection, update the internal state accordingly.
+        """
+        if not self.connected:
+            return OSError(f"{self.id} already closed")
+
+        self.connected = False
+        logging.debug(__name__ + f": close connection: {self.id}")
+        try:
+            self._writer.close()
+            await self._writer.wait_closed()
+        except OSError as e:
+            logging.warning(__name__ + f": error while closing {self.id}: {e}")
diff --git a/src/pyrobusta/transport/socket.py b/src/pyrobusta/transport/socket.py
deleted file mode 100644
index 2d8dc63..0000000
--- a/src/pyrobusta/transport/socket.py
+++ /dev/null
@@ -1,61 +0,0 @@
-"""
-Base class for representing a socket, providing common methods
-and member variables for the socket server to use.
-"""
-
-import asyncio
-from time import ticks_ms
-
-from ..utils import logging
-
-
-class SocketBase:
-    """
-    SocketBase class.
-    """
-
-    __slots__ = ("id", "connected", "reader", "writer", "last_event")
-
-    def __init__(self, reader, writer):
-        """
-        Base class for socket handling
-        :param reader: async reader stream object
-        :param writer: async writer stream object
-        """
-        client_info = writer.get_extra_info("peername")
-        self.id = str(client_info[0]) + ":" + str(client_info[1])
-        self.connected = True
-        self.reader = reader
-        self.writer = writer
-        self.last_event = ticks_ms()
-
-    async def read(self, read_bytes, decoding="utf8", timeout_seconds=0):
-        """
-        [Base] Implements client read function
-        :return tuple: read_error, data
-        - read_error is set to true upon timeout or other exception
-        - data holds bytes or decoded string read from the socket
-        """
-        logging.debug(__name__ + f": read from {self.id}")
-        self.last_event = ticks_ms()
-        if timeout_seconds:
-            request = await asyncio.wait_for(
-                self.reader.read(read_bytes), timeout_seconds
-            )
-        else:
-            request = await self.reader.read(read_bytes)
-        if decoding:
-            request = request.decode(decoding)
-        return request
-
-    async def close(self):
-        """
-        Async socket close method
-        """
-        logging.debug(__name__ + f": close connection: {self.id}")
-        try:
-            self.writer.close()
-            await self.writer.wait_closed()
-        except OSError as e:
-            logging.warning(__name__ + f": error while closing {self.id}: {e}")
-        self.connected = False
diff --git a/tests/system/http_dimensioning/boot.py b/tests/system/http_dimensioning/boot.py
new file mode 100644
index 0000000..72dd783
--- /dev/null
+++ b/tests/system/http_dimensioning/boot.py
@@ -0,0 +1,44 @@
+# This file is executed on every boot (including wake-boot from deepsleep)
+import machine
+import asyncio
+from gc import mem_alloc, collect
+
+import pyrobusta.server.http_server as http_server
+from pyrobusta.protocol.http import HttpEngine
+from pyrobusta.connectivity import wifi
+
+TS_DURATION = 100
+MEM_TIME_SERIES = [0] * TS_DURATION
+
+
+@HttpEngine.route("/mem/current", "GET")
+def current_usage(*_):
+    collect()
+    return "text/plain", str(mem_alloc())
+
+
+@HttpEngine.route("/mem/time-series", "GET")
+def time_series(*_):
+    return "application/json", MEM_TIME_SERIES
+
+
+async def mem_usage():
+    i = 0
+    collect()
+    while True:
+        i = (i + 1) % TS_DURATION
+        MEM_TIME_SERIES[i] = mem_alloc()
+        await asyncio.sleep(1)
+
+
+async def main():
+    server = http_server.HttpServer()
+    connected = wifi.initialize()
+    if connected and not machine.reset_cause() == machine.SOFT_RESET:
+        asyncio.create_task(server.start_socket_server())
+        asyncio.create_task(mem_usage())
+        while True:
+            await asyncio.sleep(1)
+
+
+asyncio.run(main())
diff --git a/tests/system/http_dimensioning/test.py b/tests/system/http_dimensioning/test.py
new file mode 100644
index 0000000..b191975
--- /dev/null
+++ b/tests/system/http_dimensioning/test.py
@@ -0,0 +1,350 @@
+"""
+Measure memory usage of HTTP server.
+"""
+
+import requests
+import sys
+import socket
+import subprocess
+import tempfile
+import threading
+import math
+
+from time import sleep
+
+from utils import generate_measurement_table, generate_plot
+
+# ---------------------------
+# Test configuration settings
+# ---------------------------
+LOAD_TEST_DURATION = 60
+
+base_config = {
+    "socket_max_con": 1,
+    "http_mem_cap": 0.05,
+    "http_multipart": False,
+    "http_serve_files": True,
+    "tls": False,
+    "http_port": 8080,
+    "https_port": 4443,
+    "log_level": "info",
+    "http_served_paths": "/lib/pyrobusta /www",
+}
+
+
+def get_mem_params(device):
+    """
+    Determine SRAM and buffer settings of a device
+    """
+    sram_bytes = int(
+        subprocess.run(
+            [
+                "mpremote",
+                device,
+                "exec",
+                "import gc\nprint(gc.mem_free() + gc.mem_alloc())",
+            ],
+            check=True,
+            stdout=subprocess.PIPE,
+            text=True,
+        ).stdout
+    )
+
+    (
+        send_buf_min_bytes,
+        send_buf_max_bytes,
+        recv_buf_min_bytes,
+        recv_buf_max_bytes,
+        con_overhead,
+    ) = [
+        int(i)
+        for i in subprocess.run(
+            [
+                "mpremote",
+                device,
+                "exec",
+                (
+                    "from pyrobusta.server.http_server import HttpServer\n"
+                    "print( HttpServer.SEND_BUF_MIN_BYTES,\n"
+                    "HttpServer.SEND_BUF_MAX_BYTES,\n"
+                    "HttpServer.RECV_BUF_MIN_BYTES,\n"
+                    "HttpServer.RECV_BUF_MAX_BYTES,\n"
+                    "HttpServer.CON_OVERHEAD_BYTES,\n"
+                    ")"
+                ),
+            ],
+            check=True,
+            stdout=subprocess.PIPE,
+            text=True,
+        ).stdout.split()
+    ]
+
+    buffer_small = send_buf_min_bytes + recv_buf_min_bytes + con_overhead
+    buffer_large = send_buf_max_bytes + recv_buf_max_bytes + con_overhead
+    return sram_bytes, buffer_small, buffer_large
+
+
+def get_test_config(sram_bytes, buffer_small, buffer_large):
+    socket_counts = (1, 2, 4)
+
+    def round_up_sig(x, sig=3):
+        """
+        Round up with significant digits.
+        round_up_sig(0.0012345, 2) == 0.0013
+        round_up_sig(0.0012345, 3) == 0.00124
+        """
+        if x == 0:
+            return 0
+        factor = 10 ** (sig - int(math.floor(math.log10(abs(x)))) - 1)
+        return math.ceil(x * factor) / factor
+
+    test_config = {
+        "low_mem_cap": [
+            {
+                "http_mem_cap": round_up_sig((buffer_small / sram_bytes) * max_con, 3),
+                "socket_max_con": max_con,
+            }
+            for max_con in socket_counts
+        ],
+        "high_mem_cap": [
+            {
+                "http_mem_cap": round_up_sig((buffer_large / sram_bytes) * max_con, 3),
+                "socket_max_con": max_con,
+            }
+            for max_con in socket_counts
+        ],
+        "multipart": [
+            {
+                "http_mem_cap": round_up_sig((buffer_small / sram_bytes) * max_con, 3),
+                "http_multipart": True,
+                "socket_max_con": max_con,
+            }
+            for max_con in socket_counts
+        ],
+        "tls": [
+            {
+                "http_mem_cap": round_up_sig((buffer_small / sram_bytes) * max_con, 3),
+                "tls": True,
+                "socket_max_con": max_con,
+            }
+            for max_con in socket_counts
+        ],
+    }
+    print(test_config)
+    return test_config
+
+
+# ------------
+# Test helpers
+# ------------
+
+
+def apply_mpremote_config(config, device):
+    subprocess.run(["mpremote", device, "soft-reset"], check=True)
+
+    with tempfile.NamedTemporaryFile(mode="w", encoding="utf-8") as tmp:
+        config_lines = subprocess.run(
+            ["mpremote", device, "cat", ":/pyrobusta.env"],
+            check=True,
+            stdout=subprocess.PIPE,
+            text=True,
+        ).stdout.splitlines()
+
+        current_config = {}
+
+        for line in config_lines:
+            line = line.rstrip("\r\n").split("#")[0]
+            if not line.strip():
+                continue
+            parts = line.split("=", 1)
+            key = parts[0].strip()
+            value = parts[1].strip().strip("'").strip('"')
+            current_config[key] = value
+
+        current_config.update(config)
+
+        tmp.write(
+            "\n".join([f"{key}={value}" for key, value in current_config.items()])
+            + "\n"
+        )
+        tmp.flush()
+
+        subprocess.run(
+            ["mpremote", device, "cp", tmp.name, ":/pyrobusta.env"], check=True
+        )
+        subprocess.run(["mpremote", device, "reset"], check=True)
+        sleep(15)
+
+
+def validate_device_ip(device_ip):
+    try:
+        socket.inet_aton(device_ip)
+    except socket.error:
+        print(f"Invalid device address: {device_ip}")
+        sys.exit(1)
+
+
+def measure_footprint(config, device_ip):
+    proto = "https" if config["tls"] == True else "http"
+    port = 4443 if config["tls"] == True else 8080
+    try:
+        usage = requests.get(
+            f"{proto}://{device_ip}:{port}/mem/current", verify=False
+        ).text
+        print(f"Measured: {usage}")
+    except:
+        return None
+    return int(usage)
+
+
+# ------------
+# Test methods
+# ------------
+
+
+def load_test(config, device_ip):
+    proto = "https" if config["tls"] else "http"
+    port = 4443 if config["tls"] else 8080
+    max_con = config.get("socket_max_con", 1)
+
+    base_url = f"{proto}://{device_ip}:{port}"
+
+    stop_flag = False
+    results = {
+        "ok": 0,
+        "errors": 0,
+    }
+
+    lock = threading.Lock()
+
+    def worker():
+        nonlocal stop_flag
+        while not stop_flag:
+            try:
+                resp = requests.get(
+                    f"{base_url}/index.html",
+                    verify=False,
+                    timeout=5,
+                )
+                resp.raise_for_status()
+
+                with lock:
+                    results["ok"] += 1
+
+            except Exception:
+                with lock:
+                    results["errors"] += 1
+
+    threads = []
+    for _ in range(max_con):
+        t = threading.Thread(target=worker, daemon=True)
+        t.start()
+        threads.append(t)
+
+    # Run load phase
+    sleep(LOAD_TEST_DURATION)
+
+    # Stop workers
+    stop_flag = True
+    for t in threads:
+        t.join(timeout=2)
+
+    try:
+        usage = requests.get(
+            f"{base_url}/mem/time-series",
+            verify=False,
+            timeout=5,
+        ).json()
+
+        print(f"Measured: {usage}")
+    except Exception as e:
+        print(f"WARNING - exception: {e}")
+        return {
+            "load": [],
+            "load_stats": results,
+            "concurrency": max_con,
+        }
+
+    return {
+        "load": usage,
+        "load_stats": results,
+        "concurrency": max_con,
+    }
+
+
+def test_config_delta(device_name, device_ip, base_config, config_delta={}):
+    target_config = dict(base_config)
+    target_config.update(config_delta)
+
+    if base_config == target_config and config_delta:
+        print("Base config matches target config, skipping.")
+        return None, None
+
+    if not config_delta:
+        print(f"Measure with base config: {base_config}")
+        target_config = base_config
+    else:
+        print(f"Measure with target config: {target_config}")
+        pass
+
+    apply_mpremote_config(target_config, device_name)
+    idle = measure_footprint(target_config, device_ip)
+    load = load_test(target_config, device_ip)
+    return idle, load
+
+
+if __name__ == "__main__":
+    device_id = sys.argv[1]  # mpremote id e.g. a1 (/dev/ttyACM1)
+    device_ip = sys.argv[2]
+    device_name = sys.argv[3]
+
+    validate_device_ip(device_ip)
+    apply_mpremote_config(base_config, device_id)
+
+    measured_idle, measured_load = test_config_delta(device_id, device_ip, base_config)
+    baseline = {
+        "id": "base",
+        "idle": measured_idle,
+        "config": base_config,
+    }
+    baseline.update(measured_load)
+
+    measurements = []
+    sram_bytes, buffer_small, buffer_large = get_mem_params(device_id)
+    test_config = get_test_config(sram_bytes, buffer_small, buffer_large)
+    for case in test_config:
+        delta_cnt = 0
+        for i, delta in enumerate(test_config[case]):
+            measured_idle, measured_load = test_config_delta(
+                device_id, device_ip, base_config, delta
+            )
+            if measured_idle and measured_load:
+                delta_cnt += 1
+                m = {
+                    "id": f"{case}_{delta_cnt:03d}",
+                    "idle": measured_idle,
+                    "delta": delta,
+                }
+                m.update(measured_load)
+                measurements.append(m)
+
+    print(baseline)
+    print(measurements)
+
+    table = generate_measurement_table(
+        baseline,
+        measurements,
+        excluded_keys={
+            "http_port",
+            "https_port",
+            "http_served_paths",
+            "log_level",
+            "http_serve_files",
+        },
+    )
+
+    generate_plot(baseline, device_name)
+    for m in measurements:
+        generate_plot(m, device_name)
+
+    print(table)
diff --git a/tests/system/http_dimensioning/utils.py b/tests/system/http_dimensioning/utils.py
new file mode 100644
index 0000000..b976d84
--- /dev/null
+++ b/tests/system/http_dimensioning/utils.py
@@ -0,0 +1,99 @@
+import os
+import matplotlib.pyplot as plt
+
+# -----------------------------------
+# Helpers for processing measurements
+# -----------------------------------
+
+
+def generate_measurement_table(base, measurements, excluded_keys={}):
+    """
+    Generate a table in markdown format for measurement data.
+    """
+    config_keys = set(base.get("config", {}).keys())
+
+    for m in measurements:
+        config_keys.update(m.get("delta", {}).keys())
+
+    config_keys = sorted(k for k in config_keys if k not in excluded_keys)
+    headers = ["id"] + config_keys + ["footprint_bytes"]
+    rows = []
+    base_cfg = dict(base["config"])
+    base_row = [base["id"]]
+
+    # Base config
+    for key in config_keys:
+        base_row.append(base_cfg.get(key, ""))
+
+    base_row.append(base["idle"])
+    rows.append(base_row)
+
+    # Measurements
+    for m in measurements:
+        effective_cfg = dict(base_cfg)
+        effective_cfg.update(m.get("delta", {}))
+
+        row = [m["id"]]
+        for key in config_keys:
+            row.append(effective_cfg.get(key, ""))
+
+        row.append(m["idle"])
+        rows.append(row)
+
+    header_line = "| " + " | ".join(headers) + " |"
+    separator = "| " + " | ".join("---" for _ in headers) + " |"
+    body = ["| " + " | ".join(str(v) for v in row) + " |" for row in rows]
+    return "\n".join([header_line, separator] + body)
+
+
+def generate_plot(measurement, device_name):
+    """
+    Visualize time series data of heap usage with additional annotation.
+    """
+    id = measurement["id"]
+
+    try:
+        last_idx = measurement["load"].index(0, 1)
+    except ValueError:
+        last_idx = len(measurement["load"])
+
+    xticks = list(range(last_idx))
+
+    fig, ax = plt.subplots()
+    p = ax.plot(xticks, measurement["load"][0:last_idx])
+    plt.title(f"Heap usage over time - {device_name}\n{id}")
+    plt.grid(True)
+    plt.xlabel("Time [s]")
+    plt.ylabel("Heap usage [bytes]")
+    plt.xticks(xticks)
+    for i, label in enumerate(ax.xaxis.get_ticklabels()):
+        if i % 5 == 0:
+            label.set_visible(True)
+        else:
+            label.set_visible(False)
+
+    # Additional annotation
+    load_stats = measurement.get("load_stats", {})
+    concurrency = measurement.get("concurrency", "n/a")
+
+    ok = load_stats.get("ok", 0)
+    errors = load_stats.get("errors", 0)
+
+    annotation_text = f"concurrency: {concurrency}\n" f"ok: {ok}\n" f"errors: {errors}"
+
+    plt.gca().text(
+        0.02,
+        0.98,
+        annotation_text,
+        transform=plt.gca().transAxes,
+        fontsize=9,
+        verticalalignment="top",
+        bbox=dict(boxstyle="round", alpha=0.3),
+    )
+
+    target_dir = device_name.replace("-", "_").lower()
+    if target_dir not in os.listdir("./docs/dimensioning/img/"):
+        os.mkdir(f"./docs/dimensioning/img/{target_dir}")
+
+    plt.savefig(f"./docs/dimensioning/img/{target_dir}/{id}.png")
+    plt.clf()