diff --git a/swiftnav_console/advanced_imu_tab.py b/swiftnav_console/advanced_imu_tab.py
index 8aec2c9c0..ac98a6432 100644
--- a/swiftnav_console/advanced_imu_tab.py
+++ b/swiftnav_console/advanced_imu_tab.py
@@ -15,31 +15,27 @@ def advanced_imu_tab_update() -> Dict[str, Any]:
     }
 
 
-ADVANCED_IMU_TAB: List[Dict[str, Any]] = [advanced_imu_tab_update()]
-
-
 class AdvancedImuPoints(QObject):
 
     _points: List[List[QPointF]] = [[]]
     _fields_data: List[float] = []
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     advanced_imu_tab: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.advanced_imu_tab = ADVANCED_IMU_TAB[0]
+        self.advanced_imu_tab = advanced_imu_tab_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        ADVANCED_IMU_TAB[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.advanced_imu_tab = ADVANCED_IMU_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.advanced_imu_tab = update_data
 
     def get_fields_data(self) -> List[float]:
         """Getter for _fields_data."""
diff --git a/swiftnav_console/advanced_magnetometer_tab.py b/swiftnav_console/advanced_magnetometer_tab.py
index 26f3a0bfd..0cd538a7a 100644
--- a/swiftnav_console/advanced_magnetometer_tab.py
+++ b/swiftnav_console/advanced_magnetometer_tab.py
@@ -16,32 +16,28 @@ def advanced_magnetometer_tab_update() -> Dict[str, Any]:
     }
 
 
-ADVANCED_MAGNETOMETER_TAB: List[Dict[str, Any]] = [advanced_magnetometer_tab_update()]
-
-
 class AdvancedMagnetometerPoints(QObject):
 
     _points: List[List[QPointF]] = [[]]
     _ymin: float = 0.0
     _ymax: float = 0.0
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     advanced_magnetometer_tab: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.advanced_magnetometer_tab = ADVANCED_MAGNETOMETER_TAB[0]
+        self.advanced_magnetometer_tab = advanced_magnetometer_tab_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        ADVANCED_MAGNETOMETER_TAB[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.advanced_magnetometer_tab = ADVANCED_MAGNETOMETER_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.advanced_magnetometer_tab = update_data
 
     def get_ymin(self) -> float:
         """Getter for _ymin."""
diff --git a/swiftnav_console/advanced_networking_tab.py b/swiftnav_console/advanced_networking_tab.py
index 00e9ebc81..87a1b8b76 100644
--- a/swiftnav_console/advanced_networking_tab.py
+++ b/swiftnav_console/advanced_networking_tab.py
@@ -17,32 +17,28 @@ def advanced_networking_tab_update() -> Dict[str, Any]:
     }
 
 
-ADVANCED_NETWORKING_TAB: List[Dict[str, Any]] = [advanced_networking_tab_update()]
-
-
 class AdvancedNetworkingData(QObject):
     _network_info: List[List[str]] = []
     _running: bool = False
     _ip_address: str = ""
     _port: int = 0
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     advanced_networking_tab: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.advanced_networking_tab = ADVANCED_NETWORKING_TAB[0]
+        self.advanced_networking_tab = advanced_networking_tab_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        ADVANCED_NETWORKING_TAB[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.advanced_networking_tab = ADVANCED_NETWORKING_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.advanced_networking_tab = update_data
 
     def get_network_info(self) -> List[List[str]]:
         """Getter for _network_info."""
diff --git a/swiftnav_console/advanced_spectrum_analyzer_tab.py b/swiftnav_console/advanced_spectrum_analyzer_tab.py
index 513ccf552..e59522626 100644
--- a/swiftnav_console/advanced_spectrum_analyzer_tab.py
+++ b/swiftnav_console/advanced_spectrum_analyzer_tab.py
@@ -20,9 +20,6 @@ def advanced_spectrum_analyzer_tab_update() -> Dict[str, Any]:
     }
 
 
-ADVANCED_SPECTRUM_ANALYZER_TAB: List[Dict[str, Any]] = [advanced_spectrum_analyzer_tab_update()]
-
-
 class AdvancedSpectrumAnalyzerPoints(QObject):
 
     _points: List[QPointF] = []
@@ -31,24 +28,23 @@ class AdvancedSpectrumAnalyzerPoints(QObject):
     _xmin: float = 0.0
     _xmax: float = 0.0
     _channel: int = 0
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     advanced_spectrum_analyzer_tab: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.advanced_spectrum_analyzer_tab = ADVANCED_SPECTRUM_ANALYZER_TAB[0]
+        self.advanced_spectrum_analyzer_tab = advanced_spectrum_analyzer_tab_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        ADVANCED_SPECTRUM_ANALYZER_TAB[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.advanced_spectrum_analyzer_tab = ADVANCED_SPECTRUM_ANALYZER_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.advanced_spectrum_analyzer_tab = update_data
 
     def get_ymin(self) -> float:
         """Getter for _ymin."""
diff --git a/swiftnav_console/advanced_system_monitor_tab.py b/swiftnav_console/advanced_system_monitor_tab.py
index cffaab953..e6e40aa5d 100644
--- a/swiftnav_console/advanced_system_monitor_tab.py
+++ b/swiftnav_console/advanced_system_monitor_tab.py
@@ -20,9 +20,6 @@ def advanced_system_monitor_tab_update() -> Dict[str, Any]:
     }
 
 
-ADVANCED_SYSTEM_MONITOR_TAB: List[Dict[str, Any]] = [advanced_system_monitor_tab_update()]
-
-
 class AdvancedSystemMonitorData(QObject):  # pylint: disable=too-many-instance-attributes
     _obs_period: List[List[Any]] = []
     _obs_latency: List[List[Any]] = []
@@ -31,24 +28,23 @@ class AdvancedSystemMonitorData(QObject):  # pylint: disable=too-many-instance-a
     _zynq_temp: float = 0.0
     _fe_temp: float = 0.0
     _csac_received: bool = False
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     advanced_system_monitor_tab: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.advanced_system_monitor_tab = ADVANCED_SYSTEM_MONITOR_TAB[0]
+        self.advanced_system_monitor_tab = advanced_system_monitor_tab_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        ADVANCED_SYSTEM_MONITOR_TAB[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.advanced_system_monitor_tab = ADVANCED_SYSTEM_MONITOR_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.advanced_system_monitor_tab = update_data
 
     def get_csac_telem_list(self) -> List[List[str]]:
         """Getter for _csac_telem_list."""
diff --git a/swiftnav_console/baseline_plot.py b/swiftnav_console/baseline_plot.py
index 385427a31..b345f3da5 100644
--- a/swiftnav_console/baseline_plot.py
+++ b/swiftnav_console/baseline_plot.py
@@ -19,9 +19,6 @@ def baseline_plot_update() -> Dict[str, Any]:
     }
 
 
-BASELINE_PLOT: List[Dict[str, Any]] = [baseline_plot_update()]
-
-
 class BaselinePlotPoints(QObject):
 
     _points: List[List[QPointF]] = [[]]
@@ -30,24 +27,23 @@ class BaselinePlotPoints(QObject):
     _n_max: float = 0.0
     _e_min: float = 0.0
     _e_max: float = 0.0
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     baseline_plot: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.baseline_plot = BASELINE_PLOT[0]
+        self.baseline_plot = baseline_plot_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        BASELINE_PLOT[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.baseline_plot = BASELINE_PLOT[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.baseline_plot = update_data
 
     def get_n_min(self) -> float:
         """Getter for _n_min."""
diff --git a/swiftnav_console/baseline_table.py b/swiftnav_console/baseline_table.py
index d37f78bdb..9fbfb2055 100644
--- a/swiftnav_console/baseline_table.py
+++ b/swiftnav_console/baseline_table.py
@@ -14,30 +14,26 @@ def baseline_table_update() -> Dict[str, Any]:
     }
 
 
-BASELINE_TABLE: List[Dict[str, Any]] = [baseline_table_update()]
-
-
 class BaselineTableEntries(QObject):
 
     _entries: List[List[str]] = []
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     baseline_table: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.baseline_table = BASELINE_TABLE[0]
+        self.baseline_table = baseline_table_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        BASELINE_TABLE[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.baseline_table = BASELINE_TABLE[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.baseline_table = update_data
 
     def get_entries(self) -> List[List[str]]:
         """Getter for _entries."""
diff --git a/swiftnav_console/connection.py b/swiftnav_console/connection.py
index 7735dcac5..33e144f80 100644
--- a/swiftnav_console/connection.py
+++ b/swiftnav_console/connection.py
@@ -23,11 +23,6 @@ def connection_update() -> Dict[str, Any]:
     }
 
 
-CONNECTION: List[Dict[str, Any]] = [connection_update()]
-CONNECTION_STATE: List[ConnectionState] = [ConnectionState.DISCONNECTED]
-CONNECTION_MESSAGE: List[str] = [""]
-
-
 class ConnectionData(QObject):  # pylint: disable=too-many-instance-attributes disable=too-many-public-methods
 
     _available_ports: List[str] = []
@@ -43,7 +38,9 @@ class ConnectionData(QObject):  # pylint: disable=too-many-instance-attributes d
     _console_version: str = ""
     _previous_connection_type: ConnectionType = ConnectionType.Serial
     _connection_message: str = ""
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
+    _state_updated = Signal(ConnectionState)
+    _message_updated = Signal(str)
     connection: Dict[str, Any] = {}
     connection_state: ConnectionState = ConnectionState.DISCONNECTED
     connection_msg: str = ""
@@ -52,31 +49,36 @@ def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.connection = CONNECTION[0]
-        self.connection_state = CONNECTION_STATE[0]
-        self.connection_msg = CONNECTION_MESSAGE[0]
+        self.connection = connection_update()
+        self.connection_state = ConnectionState.DISCONNECTED
+        self.connection_msg = ""
         self._data_updated.connect(self.handle_data_updated)
+        self._state_updated.connect(self.handle_state_updated)
+        self._message_updated.connect(self.handle_message_updated)
 
     @classmethod
     def post_connection_state_update(cls, update_data: ConnectionState) -> None:
-        CONNECTION_STATE[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._state_updated.emit(update_data)
 
     @classmethod
     def post_connection_message_update(cls, update_data: str) -> None:
-        CONNECTION_MESSAGE[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._message_updated.emit(update_data)
 
     @classmethod
     def post_connection_data_update(cls, update_data: Dict[str, Any]) -> None:
-        CONNECTION[0] = update_data
-        cls._instance._data_updated.emit()
-
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.connection_state = CONNECTION_STATE[0]
-        self.connection_msg = CONNECTION_MESSAGE[0]
-        self.connection = CONNECTION[0]
+        cls._instance._data_updated.emit(update_data)
+
+    @Slot(ConnectionState)  # type: ignore
+    def handle_state_updated(self, data: ConnectionState) -> None:
+        self.connection_state = data
+
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.connection = update_data
+
+    @Slot(str)  # type: ignore
+    def handle_message_updated(self, data: str) -> None:
+        self.connection_msg = data
 
     def get_available_ports(self) -> List[str]:
         return self._available_ports
diff --git a/swiftnav_console/fusion_status_flags.py b/swiftnav_console/fusion_status_flags.py
index 4216cabe8..fee51f8a3 100644
--- a/swiftnav_console/fusion_status_flags.py
+++ b/swiftnav_console/fusion_status_flags.py
@@ -1,7 +1,7 @@
 """Fusion Status Bar QObjects.
 """
 
-from typing import Dict, Any, List
+from typing import Dict, Any
 
 from PySide2.QtCore import Property, QObject, Signal, Slot
 
@@ -19,9 +19,6 @@ def fusion_status_flags_update() -> Dict[str, Any]:
     }
 
 
-FUSION_STATUS_FLAGS: List[Dict[str, Any]] = [fusion_status_flags_update()]
-
-
 class FusionStatusFlagsData(QObject):
 
     _gnsspos: str = FusionStatus.UNKNOWN
@@ -30,7 +27,7 @@ class FusionStatusFlagsData(QObject):
     _speed: str = FusionStatus.UNKNOWN
     _nhc: str = FusionStatus.UNKNOWN
     _zerovel: str = FusionStatus.UNKNOWN
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     fusion_status_flags: Dict[str, Any] = {}
 
     def __init__(self):
@@ -42,12 +39,11 @@ def __init__(self):
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        FUSION_STATUS_FLAGS[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.fusion_status_flags = FUSION_STATUS_FLAGS[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.fusion_status_flags = update_data
 
     def get_gnsspos(self) -> str:
         return self._gnsspos
diff --git a/swiftnav_console/log_panel.py b/swiftnav_console/log_panel.py
index aadd925da..dc82ed5c2 100644
--- a/swiftnav_console/log_panel.py
+++ b/swiftnav_console/log_panel.py
@@ -18,31 +18,27 @@ def log_panel_update() -> Dict[str, Any]:
     }
 
 
-LOG_PANEL: List[Dict[str, Any]] = [log_panel_update()]
-
-
 class LogPanelData(QObject):
     _entries: List[Dict[str, str]] = []
     _log_level_labels: List[str] = []
     _log_level: str
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     log_panel: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.log_panel = LOG_PANEL[0]
+        self.log_panel = log_panel_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        LOG_PANEL[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.log_panel = LOG_PANEL[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.log_panel = update_data
 
     def get_log_level_labels(self) -> List[str]:
         return self._log_level_labels
diff --git a/swiftnav_console/logging_bar.py b/swiftnav_console/logging_bar.py
index e959f1382..2f7d9c45f 100644
--- a/swiftnav_console/logging_bar.py
+++ b/swiftnav_console/logging_bar.py
@@ -40,7 +40,9 @@ class LoggingBarData(QObject):  # pylint: disable=too-many-instance-attributes
     _recording_duration_sec: int = 0
     _recording_size: float = 0
     _recording_filename: str = ""
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
+    _recording_updated = Signal(dict)
+
     logging_bar: Dict[str, Any] = {}
     logging_bar_recording: Dict[str, Any] = {}
 
@@ -51,21 +53,23 @@ def __init__(self):
         self.logging_bar = logging_bar_update()
         self.logging_bar_recording = logging_bar_recording_update()
         self._data_updated.connect(self.handle_data_updated)
+        self._recording_updated.connect(self.handle_recording_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        LOGGING_BAR[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
     @classmethod
     def post_recording_data_update(cls, update_data: Dict[str, Any]) -> None:
-        LOGGING_BAR_RECORDING[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._recording_updated.emit(update_data)
+
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.logging_bar = update_data
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.logging_bar = LOGGING_BAR[0]
-        self.logging_bar_recording = LOGGING_BAR_RECORDING[0]
+    @Slot(dict)  # type: ignore
+    def handle_recording_updated(self, update_data: Dict[str, Any]) -> None:
+        self.logging_bar_recording = update_data
 
     def get_csv_logging(self) -> bool:
         return self._csv_logging
diff --git a/swiftnav_console/observation_tab.py b/swiftnav_console/observation_tab.py
index bffff0621..d6ee95734 100644
--- a/swiftnav_console/observation_tab.py
+++ b/swiftnav_console/observation_tab.py
@@ -50,10 +50,6 @@ def observation_update() -> Dict[str, Any]:
     }
 
 
-REMOTE_OBSERVATION_TAB: List[Dict[str, Any]] = [observation_update()]
-LOCAL_OBSERVATION_TAB: List[Dict[str, Any]] = [observation_update()]
-
-
 class ObservationTableModel(QAbstractTableModel):  # pylint: disable=too-many-public-methods
     # pylint: disable=too-many-instance-attributes
     # Might want to move the column_widths logic into QML and use QML's
@@ -66,7 +62,7 @@ class ObservationTableModel(QAbstractTableModel):  # pylint: disable=too-many-pu
     show_gps_only_changed = Signal(bool, arguments="show_gps_only")
     codes_changed = Signal()
     dataPopulated = Signal()
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     _observation_tab: Dict[str, Any] = {}
 
     column_metadata = [
@@ -101,18 +97,11 @@ def __init__(self, parent=None):
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        if cls._instance.get_remote():
-            REMOTE_OBSERVATION_TAB[0] = update_data
-        else:
-            LOCAL_OBSERVATION_TAB[0] = update_data
-        cls._instance._data_updated.emit()  # pylint: disable=protected-access
+        cls._instance._data_updated.emit(update_data)  # pylint: disable=protected-access
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        if self._remote:
-            self._observation_tab = REMOTE_OBSERVATION_TAB[0]
-        else:
-            self._observation_tab = LOCAL_OBSERVATION_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self._observation_tab = update_data
 
     def get_codes(self) -> List[List[str]]:
         return [entry["prn"].code for entry in self._observation_tab[Keys.ROWS]]
diff --git a/swiftnav_console/settings_tab.py b/swiftnav_console/settings_tab.py
index dc2bb328c..d7d32888c 100644
--- a/swiftnav_console/settings_tab.py
+++ b/swiftnav_console/settings_tab.py
@@ -21,19 +21,15 @@ def settings_table_update() -> Dict[str, Any]:
     }
 
 
-SETTINGS_IMPORT_STATUS: List[str] = [""]
-SETTINGS_INS: List[Dict[str, Any]] = [settings_ins_update()]
-SETTINGS_NOTIFICATION: List[str] = [""]
-SETTINGS_TABLE: List[Dict[str, Any]] = [settings_table_update()]
-
-
 class SettingsTabData(QObject):
 
     _import_status: str = ""
     _recommended_ins_settings: List[List[Any]] = []
     _new_ins_confirmation: bool = False
     _notification: str = ""
-    _data_updated = Signal()
+    _import_status_updated = Signal(str)
+    _ins_updated = Signal(dict)
+    _notification_updated = Signal(str)
     settings_import_status: str = ""
     settings_ins: Dict[str, Any] = {}
     settings_notification: str = ""
@@ -42,31 +38,36 @@ def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.settings_import_status = SETTINGS_IMPORT_STATUS[0]
-        self.settings_ins = SETTINGS_INS[0]
-        self.settings_notification = SETTINGS_NOTIFICATION[0]
-        self._data_updated.connect(self.handle_data_updated)
+        self.settings_import_status = ""
+        self.settings_ins = settings_ins_update()
+        self.settings_notification = ""
+        self._import_status_updated.connect(self.handle_import_status_updated)
+        self._ins_updated.connect(self.handle_ins_updated)
+        self._notification_updated.connect(self.handle_notification_updated)
 
     @classmethod
     def post_import_status_update(cls, update_data: str) -> None:
-        SETTINGS_IMPORT_STATUS[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._import_status_updated.emit(update_data)
 
     @classmethod
     def post_ins_update(cls, update_data: Dict[str, Any]) -> None:
-        SETTINGS_INS[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._ins_updated.emit(update_data)
 
     @classmethod
     def post_notification_update(cls, update_data: str) -> None:
-        SETTINGS_NOTIFICATION[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._notification_updated.emit(update_data)
+
+    @Slot(str)  # type: ignore
+    def handle_import_status_updated(self, data: str) -> None:
+        self.settings_import_status = data
+
+    @Slot(dict)  # type: ignore
+    def handle_ins_updated(self, update_data: Dict[str, Any]) -> None:
+        self.settings_ins = update_data
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.settings_import_status = SETTINGS_IMPORT_STATUS[0]
-        self.settings_ins = SETTINGS_INS[0]
-        self.settings_notification = SETTINGS_NOTIFICATION[0]
+    @Slot(str)  # type: ignore
+    def handle_notification_updated(self, data: str) -> None:
+        self.settings_notification = data
 
     def get_import_status(self) -> str:
         return self._import_status
@@ -129,24 +130,23 @@ def clear_new_ins_confirmation(self, cp: SettingsTabData) -> SettingsTabData:  #
 class SettingsTableEntries(QObject):
 
     _entries: List[dict] = []
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     settings_table: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.settings_table = SETTINGS_TABLE[0]
+        self.settings_table = settings_table_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        SETTINGS_TABLE[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.settings_table = SETTINGS_TABLE[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.settings_table = update_data
 
     def get_entries(self) -> List[dict]:
         return self._entries
diff --git a/swiftnav_console/solution_position_tab.py b/swiftnav_console/solution_position_tab.py
index 102419e65..a51bcad8d 100644
--- a/swiftnav_console/solution_position_tab.py
+++ b/swiftnav_console/solution_position_tab.py
@@ -20,9 +20,6 @@ def solution_position_update() -> Dict[str, Any]:
     }
 
 
-SOLUTION_POSITION_TAB: List[Dict[str, Any]] = [solution_position_update()]
-
-
 class SolutionPositionPoints(QObject):  # pylint: disable=too-many-instance-attributes,too-many-public-methods
 
     _points: List[List[QPointF]] = [[]]
@@ -32,24 +29,23 @@ class SolutionPositionPoints(QObject):  # pylint: disable=too-many-instance-attr
     _lon_min: float = 0.0
     _lon_max: float = 0.0
     _available_units: List[str] = []
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     solution_position: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.solution_position = SOLUTION_POSITION_TAB[0]
+        self.solution_position = solution_position_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        SOLUTION_POSITION_TAB[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.solution_position = SOLUTION_POSITION_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.solution_position = update_data
 
     def get_lat_min(self) -> float:
         """Getter for _lat_min."""
diff --git a/swiftnav_console/solution_table.py b/swiftnav_console/solution_table.py
index 7c84a7b64..07f17bd5a 100644
--- a/swiftnav_console/solution_table.py
+++ b/swiftnav_console/solution_table.py
@@ -21,24 +21,23 @@ class SolutionTableEntries(QObject):
 
     _entries: List[List[str]] = []
     _valid: bool = False
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     solution_table: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.solution_table = SOLUTION_TABLE[0]
+        self.solution_table = solution_table_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        SOLUTION_TABLE[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.solution_table = SOLUTION_TABLE[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.solution_table = update_data
 
     def get_valid(self) -> bool:
         """Getter for _valid.
diff --git a/swiftnav_console/solution_velocity_tab.py b/swiftnav_console/solution_velocity_tab.py
index 7b9708743..29fac8094 100644
--- a/swiftnav_console/solution_velocity_tab.py
+++ b/swiftnav_console/solution_velocity_tab.py
@@ -18,9 +18,6 @@ def solution_velocity_update() -> Dict[str, Any]:
     }
 
 
-SOLUTION_VELOCITY_TAB: List[Dict[str, Any]] = [solution_velocity_update()]
-
-
 class SolutionVelocityPoints(QObject):
 
     _colors: List[str] = []
@@ -29,24 +26,23 @@ class SolutionVelocityPoints(QObject):
     _min: float = 0.0
     _max: float = 0.0
     _available_units: List[str] = []
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     solution_velocity: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.solution_velocity = SOLUTION_VELOCITY_TAB[0]
+        self.solution_velocity = solution_velocity_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        SOLUTION_VELOCITY_TAB[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.solution_velocity = SOLUTION_VELOCITY_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.solution_velocity = update_data
 
     def get_valid(self) -> bool:
         """Getter for _valid.
diff --git a/swiftnav_console/status_bar.py b/swiftnav_console/status_bar.py
index 31ad245af..27c64e23b 100644
--- a/swiftnav_console/status_bar.py
+++ b/swiftnav_console/status_bar.py
@@ -1,7 +1,7 @@
 """Status Bar QObjects.
 """
 
-from typing import Dict, List, Any
+from typing import Dict, Any
 
 from PySide2.QtCore import Property, QObject, Signal, Slot
 
@@ -22,9 +22,6 @@ def status_bar_update() -> Dict[str, Any]:
     }
 
 
-STATUS_BAR: List[Dict[str, Any]] = [status_bar_update()]
-
-
 class StatusBarData(QObject):  # pylint: disable=too-many-instance-attributes
 
     _pos: str = ""
@@ -36,24 +33,23 @@ class StatusBarData(QObject):  # pylint: disable=too-many-instance-attributes
     _solid_connection: bool = False
     _title: str = ""
     _antenna_status: str = ""
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     status_bar: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.status_bar = STATUS_BAR[0]
+        self.status_bar = status_bar_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        STATUS_BAR[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.status_bar = STATUS_BAR[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.status_bar = update_data
 
     def get_pos(self) -> str:
         return self._pos
diff --git a/swiftnav_console/tracking_signals_tab.py b/swiftnav_console/tracking_signals_tab.py
index b558f3eb3..cfb1d5acc 100644
--- a/swiftnav_console/tracking_signals_tab.py
+++ b/swiftnav_console/tracking_signals_tab.py
@@ -19,8 +19,6 @@ def tracking_signals_tab_update() -> Dict[str, Any]:
     }
 
 
-TRACKING_SIGNALS_TAB: List[Dict[str, Any]] = [tracking_signals_tab_update()]
-
 # pylint:disable=too-many-instance-attributes
 class TrackingSignalsPoints(QObject):
 
@@ -37,24 +35,23 @@ class TrackingSignalsPoints(QObject):
     check_labels_changed = Signal()
     all_series_changed = Signal()
     enabled_series_changed = Signal()
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     _tracking_signals_tab: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self._tracking_signals_tab = TRACKING_SIGNALS_TAB[0]
+        self._tracking_signals_tab = tracking_signals_tab_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        TRACKING_SIGNALS_TAB[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self._tracking_signals_tab = TRACKING_SIGNALS_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self._tracking_signals_tab = update_data
 
     def get_num_labels(self) -> int:  # pylint:disable=no-self-use
         return len(self._tracking_signals_tab[Keys.LABELS])
diff --git a/swiftnav_console/tracking_sky_plot_tab.py b/swiftnav_console/tracking_sky_plot_tab.py
index 642a72471..8e65ca0cc 100644
--- a/swiftnav_console/tracking_sky_plot_tab.py
+++ b/swiftnav_console/tracking_sky_plot_tab.py
@@ -16,14 +16,11 @@ def tracking_sky_plot_update() -> Dict[str, Any]:
     }
 
 
-TRACKING_SKY_PLOT_TAB: List[Dict[str, Any]] = [tracking_sky_plot_update()]
-
-
 class TrackingSkyPlotPoints(QObject):
 
     _labels: List[List[str]] = []
     _all_series: List[QtCharts.QXYSeries] = []
-    _data_updated = Signal()
+    _data_updated = Signal(dict)
     labels_changed = Signal()
     all_series_changed = Signal()
     _tracking_sky_plot: Dict[str, Any] = {}
@@ -32,17 +29,16 @@ def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self._tracking_sky_plot = TRACKING_SKY_PLOT_TAB[0]
+        self._tracking_sky_plot = tracking_sky_plot_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        TRACKING_SKY_PLOT_TAB[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self._tracking_sky_plot = TRACKING_SKY_PLOT_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self._tracking_sky_plot = update_data
 
     def get_labels(self) -> List[List[str]]:  # pylint:disable=no-self-use
         return self._tracking_sky_plot[Keys.LABELS]
diff --git a/swiftnav_console/update_tab.py b/swiftnav_console/update_tab.py
index e236661d2..62cd60be2 100644
--- a/swiftnav_console/update_tab.py
+++ b/swiftnav_console/update_tab.py
@@ -1,7 +1,7 @@
 """Status Bar QObjects.
 """
 
-from typing import Any, Dict, List
+from typing import Any, Dict
 
 from PySide2.QtCore import Property, QObject, Signal, Slot
 
@@ -29,9 +29,6 @@ def update_tab_update() -> Dict[str, Any]:
     }
 
 
-UPDATE_TAB: List[Dict[str, Any]] = [update_tab_update()]
-
-
 class UpdateTabData(QObject):  # pylint: disable=too-many-instance-attributes,too-many-public-methods
 
     _hardware_revision: str = ""
@@ -50,24 +47,23 @@ class UpdateTabData(QObject):  # pylint: disable=too-many-instance-attributes,to
     _console_outdated: bool = False
     _console_version_current: str = ""
     _console_version_latest: str = ""
-    _data_updated: Signal = Signal()
+    _data_updated: Signal = Signal(dict)
     update_tab: Dict[str, Any] = {}
 
     def __init__(self):
         super().__init__()
         assert getattr(self.__class__, "_instance", None) is None
         self.__class__._instance = self
-        self.update_tab = UPDATE_TAB[0]
+        self.update_tab = update_tab_update()
         self._data_updated.connect(self.handle_data_updated)
 
     @classmethod
     def post_data_update(cls, update_data: Dict[str, Any]) -> None:
-        UPDATE_TAB[0] = update_data
-        cls._instance._data_updated.emit()
+        cls._instance._data_updated.emit(update_data)
 
-    @Slot()  # type: ignore
-    def handle_data_updated(self) -> None:
-        self.update_tab = UPDATE_TAB[0]
+    @Slot(dict)  # type: ignore
+    def handle_data_updated(self, update_data: Dict[str, Any]) -> None:
+        self.update_tab = update_data
 
     def get_hardware_revision(self) -> str:
         return self._hardware_revision