diff --git a/core/frontend/src/components/autopilot/MasterEndpointManager.vue b/core/frontend/src/components/autopilot/MasterEndpointManager.vue
new file mode 100644
index 0000000000..4c4d79f3f6
--- /dev/null
+++ b/core/frontend/src/components/autopilot/MasterEndpointManager.vue
@@ -0,0 +1,217 @@
+<template>
+  <div class="master-endpoint-manager d-flex flex-column align-center">
+    <v-card
+      width="100%"
+      class="pa-4"
+    >
+      <v-card-title class="text-h6 mb-2">
+        Master Endpoint Configuration
+      </v-card-title>
+
+      <v-form
+        ref="form"
+        v-model="form_valid"
+        lazy-validation
+      >
+        <v-select
+          v-model="endpoint.connection_type"
+          :items="endpoint_types"
+          label="Connection Type"
+          :rules="[validate_required_field]"
+          @change="updateDefaultPlace"
+        />
+
+        <v-text-field
+          v-model="endpoint.place"
+          :rules="[validate_required_field, is_ip_address_path, is_useable_ip_address]"
+          label="IP/Device"
+        />
+
+        <v-text-field
+          v-model.number="endpoint.argument"
+          label="Port/Baudrate"
+          :rules="[is_socket_port_baudrate]"
+        />
+
+        <v-card-actions class="mt-4">
+          <v-spacer />
+          <v-btn
+            color="primary"
+            :loading="saving"
+            :disabled="!form_valid || !has_changes"
+            @click="saveEndpoint"
+          >
+            Save Changes
+          </v-btn>
+        </v-card-actions>
+      </v-form>
+    </v-card>
+
+    <v-snackbar
+      v-model="show_success"
+      color="success"
+      timeout="3000"
+    >
+      Master endpoint updated successfully
+      <template #action="{ attrs }">
+        <v-btn
+          text
+          v-bind="attrs"
+          @click="show_success = false"
+        >
+          Close
+        </v-btn>
+      </template>
+    </v-snackbar>
+  </div>
+</template>
+
+<script lang="ts">
+import Vue from 'vue'
+
+import Notifier from '@/libs/notifier'
+import autopilot from '@/store/autopilot_manager'
+import beacon from '@/store/beacon'
+import { AutopilotEndpoint, EndpointType, userFriendlyEndpointType } from '@/types/autopilot'
+import { autopilot_service } from '@/types/frontend_services'
+import { VForm } from '@/types/vuetify'
+import back_axios from '@/utils/api'
+import {
+  isBaudrate, isFilepath, isIpAddress, isNotEmpty, isSocketPort,
+} from '@/utils/pattern_validators'
+
+const notifier = new Notifier(autopilot_service)
+
+const defaultEndpoint: AutopilotEndpoint = {
+  name: 'master',
+  owner: 'User',
+  connection_type: EndpointType.udpin,
+  place: '0.0.0.0',
+  argument: 14551,
+  persistent: true,
+  protected: false,
+  enabled: true,
+}
+
+export default Vue.extend({
+  name: 'MasterEndpointManager',
+  data() {
+    return {
+      form_valid: true,
+      saving: false,
+      show_success: false,
+      original_endpoint: { ...defaultEndpoint },
+      endpoint: { ...defaultEndpoint },
+    }
+  },
+  computed: {
+    endpoint_types(): {value: EndpointType, text: string}[] {
+      return Object.entries(EndpointType).map(
+        (type) => ({ value: type[1], text: userFriendlyEndpointType(type[1]) }),
+      )
+    },
+    form(): VForm {
+      return this.$refs.form as VForm
+    },
+    user_ip_address(): string {
+      return beacon.client_ip_address
+    },
+    available_ips(): string[] {
+      return [...new Set(beacon.available_domains.map((domain) => domain.ip))]
+    },
+    has_changes(): boolean {
+      return this.endpoint.connection_type !== this.original_endpoint.connection_type
+        || this.endpoint.place !== this.original_endpoint.place
+        || this.endpoint.argument !== this.original_endpoint.argument
+    },
+  },
+  mounted() {
+    this.fetchCurrentEndpoint()
+  },
+  methods: {
+    validate_required_field(input: string): (true | string) {
+      return isNotEmpty(input) ? true : 'Required field.'
+    },
+    is_ip_address_path(input: string): (true | string) {
+      return isIpAddress(input) || isFilepath(input) ? true : 'Invalid IP/Device-path.'
+    },
+    is_useable_ip_address(input: string): (true | string) {
+      if ([EndpointType.udpin, EndpointType.tcpin].includes(this.endpoint.connection_type)) {
+        if (!['0.0.0.0', ...this.available_ips].includes(input)) {
+          return 'This IP is not available at any of the network interfaces.'
+        }
+      }
+      if ([EndpointType.udpout, EndpointType.tcpout].includes(this.endpoint.connection_type)) {
+        if (input === '0.0.0.0') return '0.0.0.0 as a client is undefined behavior.'
+      }
+      return true
+    },
+    is_socket_port_baudrate(input: number): (true | string) {
+      if (typeof input === 'string') {
+        return 'Please use an integer value.'
+      }
+      return isSocketPort(input) || isBaudrate(input) ? true : 'Invalid Port/Baudrate.'
+    },
+    updateDefaultPlace(): void {
+      switch (this.endpoint.connection_type) {
+        case EndpointType.udpin:
+        case EndpointType.tcpin:
+          this.endpoint.place = '0.0.0.0'
+          break
+        case EndpointType.udpout:
+        case EndpointType.tcpout:
+          this.endpoint.place = this.user_ip_address
+          break
+        default:
+          this.endpoint.place = '/dev/ttyAMA1' // Serial3
+      }
+    },
+    async fetchCurrentEndpoint(): Promise<void> {
+      try {
+        const response = await back_axios({
+          method: 'get',
+          url: `${autopilot.API_URL}/endpoints/manual_board_master_endpoint`,
+          timeout: 10000,
+        })
+        const endpoint_data = {
+          ...defaultEndpoint,
+          ...response.data,
+        }
+        this.endpoint = { ...endpoint_data }
+        this.original_endpoint = { ...endpoint_data }
+      } catch (error) {
+        notifier.pushBackError('MASTER_ENDPOINT_FETCH_FAIL', error)
+      }
+    },
+    async saveEndpoint(): Promise<void> {
+      if (!this.form.validate()) {
+        return
+      }
+
+      this.saving = true
+      try {
+        await back_axios({
+          method: 'post',
+          url: `${autopilot.API_URL}/endpoints/manual_board_master_endpoint`,
+          timeout: 10000,
+          data: this.endpoint,
+        })
+        this.original_endpoint = { ...this.endpoint }
+        this.show_success = true
+      } catch (error) {
+        notifier.pushBackError('MASTER_ENDPOINT_SAVE_FAIL', error)
+      } finally {
+        this.saving = false
+      }
+    },
+  },
+})
+</script>
+
+<style scoped>
+.master-endpoint-manager {
+  width: 100%;
+  max-width: 600px;
+  margin: 0 auto;
+}
+</style>
diff --git a/core/frontend/src/views/Autopilot.vue b/core/frontend/src/views/Autopilot.vue
index 0239c09f22..d209a52be7 100644
--- a/core/frontend/src/views/Autopilot.vue
+++ b/core/frontend/src/views/Autopilot.vue
@@ -44,7 +44,17 @@
           <br>
         </div>
         <not-safe-overlay />
-        <v-expansion-panels>
+        <v-expansion-panels v-if="is_external_board">
+          <v-expansion-panel>
+            <v-expansion-panel-header>
+              Master endpoint
+            </v-expansion-panel-header>
+            <v-expansion-panel-content>
+              <master-endpoint-manager />
+            </v-expansion-panel-content>
+          </v-expansion-panel>
+        </v-expansion-panels>
+        <v-expansion-panels v-else>
           <v-expansion-panel>
             <v-expansion-panel-header>
               Firmware update
@@ -78,7 +88,7 @@
           Change board
         </v-btn>
         <v-btn
-          v-if="settings.is_pirate_mode"
+          v-if="settings.is_pirate_mode && board_supports_start_stop"
           class="ma-1"
           :block="$vuetify.breakpoint.xs"
           color="secondary"
@@ -88,7 +98,7 @@
           Start autopilot
         </v-btn>
         <v-btn
-          v-if="settings.is_pirate_mode"
+          v-if="settings.is_pirate_mode && board_supports_start_stop"
           class="ma-1"
           :block="$vuetify.breakpoint.xs"
           color="secondary"
@@ -98,6 +108,7 @@
           Stop autopilot
         </v-btn>
         <v-btn
+          v-if="settings.is_pirate_mode && board_supports_restart"
           color="primary"
           class="ma-1"
           :block="$vuetify.breakpoint.xs"
@@ -127,6 +138,7 @@ import {
 import AutopilotSerialConfiguration from '@/components/autopilot/AutopilotSerialConfiguration.vue'
 import BoardChangeDialog from '@/components/autopilot/BoardChangeDialog.vue'
 import FirmwareManager from '@/components/autopilot/FirmwareManager.vue'
+import MasterEndpointManager from '@/components/autopilot/MasterEndpointManager.vue'
 import NotSafeOverlay from '@/components/common/NotSafeOverlay.vue'
 import { MavAutopilot } from '@/libs/MAVLink2Rest/mavlink2rest-ts/messages/mavlink2rest-enum'
 import Notifier from '@/libs/notifier'
@@ -148,6 +160,7 @@ export default Vue.extend({
     FirmwareManager,
     AutopilotSerialConfiguration,
     NotSafeOverlay,
+    MasterEndpointManager,
   },
   data() {
     return {
@@ -161,6 +174,13 @@ export default Vue.extend({
     }
   },
   computed: {
+    board_supports_start_stop(): boolean {
+      return this.current_board?.name !== 'Manual'
+    },
+    board_supports_restart(): boolean {
+      // this is a mavlink command, all boards should support it
+      return true
+    },
     autopilot_info(): Record<string, string> {
       let version = 'Unknown'
       if (this.firmware_info) {
@@ -201,6 +221,9 @@ export default Vue.extend({
       }
       return ['Navigator', 'Navigator64', 'SITL'].includes(boardname)
     },
+    is_external_board(): boolean {
+      return autopilot.current_board?.name === 'Manual'
+    },
     current_board(): FlightController | null {
       return autopilot.current_board
     },
diff --git a/core/services/ardupilot_manager/api/v1/routers/endpoints.py b/core/services/ardupilot_manager/api/v1/routers/endpoints.py
index 7b5d6f6635..4115d06de1 100644
--- a/core/services/ardupilot_manager/api/v1/routers/endpoints.py
+++ b/core/services/ardupilot_manager/api/v1/routers/endpoints.py
@@ -34,3 +34,13 @@ async def remove_endpoints(endpoints: Set[Endpoint] = Body(...)) -> Any:
 @endpoints_router_v1.put("/", status_code=status.HTTP_200_OK)
 async def update_endpoints(endpoints: Set[Endpoint] = Body(...)) -> Any:
     await autopilot.update_endpoints(endpoints)
+
+
+@endpoints_router_v1.post("/manual_board_master_endpoint", summary="Set the master endpoint for an manual board.")
+async def set_manual_board_master_endpoint(endpoint: Endpoint) -> bool:
+    return await autopilot.set_manual_board_master_endpoint(endpoint)
+
+
+@endpoints_router_v1.get("/manual_board_master_endpoint", summary="Get the master endpoint for an manual board.")
+def get_manual_board_master_endpoint() -> Any:
+    return autopilot.get_manual_board_master_endpoint()
diff --git a/core/services/ardupilot_manager/autopilot_manager.py b/core/services/ardupilot_manager/autopilot_manager.py
index 34bc254889..1ee761a36c 100644
--- a/core/services/ardupilot_manager/autopilot_manager.py
+++ b/core/services/ardupilot_manager/autopilot_manager.py
@@ -390,6 +390,12 @@ def load_preferred_router(self) -> Optional[str]:
     def get_available_routers(self) -> List[str]:
         return [router.name() for router in self.mavlink_manager.available_interfaces()]
 
+    async def start_manual_board(self, board: FlightController) -> None:
+        self._current_board = board
+        self.master_endpoint = self.get_manual_board_master_endpoint()
+        self.ardupilot_subprocess = None
+        await self.start_mavlink_manager(self.master_endpoint)
+
     async def start_sitl(self) -> None:
         self._current_board = BoardDetector.detect_sitl()
         if not self.firmware_manager.is_firmware_installed(self._current_board):
@@ -486,9 +492,9 @@ def get_board_to_be_used(self, boards: List[FlightController]) -> FlightControll
         # SITL should only be used if explicitly set by user, in which case it's a preferred board and the
         # previous return logic will get it. We do this to prevent the user thinking that it's physical board
         # is correctly running when in fact it was SITL automatically starting.
-        real_boards = [board for board in boards if board.type != PlatformType.SITL]
+        real_boards = [board for board in boards if board.type not in [PlatformType.SITL, PlatformType.Manual]]
         if not real_boards:
-            raise RuntimeError("Only available board is SITL, and it wasn't explicitly chosen.")
+            raise RuntimeError("No physical board detected and SITL/Manual board aren't explicitly chosen.")
         real_boards.sort(key=lambda board: board.platform)
         return real_boards[0]
 
@@ -584,6 +590,8 @@ async def start_ardupilot(self) -> None:
                 await self.start_serial(flight_controller)
             elif flight_controller.platform == Platform.SITL:
                 await self.start_sitl()
+            elif flight_controller.platform == Platform.Manual:
+                await self.start_manual_board(flight_controller)
             else:
                 raise RuntimeError(f"Invalid board type: {flight_controller}")
         finally:
@@ -662,3 +670,25 @@ async def install_firmware_from_url(
 
     async def restore_default_firmware(self, board: FlightController) -> None:
         await self.firmware_manager.restore_default_firmware(board)
+
+    async def set_manual_board_master_endpoint(self, endpoint: Endpoint) -> bool:
+        self.configuration["manual_board_master_endpoint"] = endpoint.as_dict()
+        self.settings.save(self.configuration)
+        self.mavlink_manager.master_endpoint = endpoint
+        await self.mavlink_manager.restart()
+        return True
+
+    def get_manual_board_master_endpoint(self) -> Endpoint:
+        default_master_endpoint = Endpoint(
+            name="Manual Board Master Endpoint",
+            owner=self.settings.app_name,
+            connection_type=EndpointType.UDPServer,
+            place="0.0.0.0",
+            argument=14551,
+            persistent=True,
+            enabled=True,
+        )
+        endpoint = self.configuration.get("manual_board_master_endpoint", None)
+        if endpoint is None:
+            return default_master_endpoint
+        return Endpoint(**endpoint)
diff --git a/core/services/ardupilot_manager/flight_controller_detector/Detector.py b/core/services/ardupilot_manager/flight_controller_detector/Detector.py
index a1753a14b8..6eba0fdc1b 100644
--- a/core/services/ardupilot_manager/flight_controller_detector/Detector.py
+++ b/core/services/ardupilot_manager/flight_controller_detector/Detector.py
@@ -77,7 +77,7 @@ def detect_sitl() -> FlightController:
         return FlightController(name="SITL", manufacturer="ArduPilot Team", platform=Platform.SITL)
 
     @classmethod
-    async def detect(cls, include_sitl: bool = True) -> List[FlightController]:
+    async def detect(cls, include_sitl: bool = True, include_manual: bool = True) -> List[FlightController]:
         """Return a list of available flight controllers
 
         Arguments:
@@ -99,4 +99,7 @@ async def detect(cls, include_sitl: bool = True) -> List[FlightController]:
         if include_sitl:
             available.append(Detector.detect_sitl())
 
+        if include_manual:
+            available.append(FlightController(name="Manual", manufacturer="Manual", platform=Platform.Manual))
+
         return available
diff --git a/core/services/ardupilot_manager/mavlink_proxy/AbstractRouter.py b/core/services/ardupilot_manager/mavlink_proxy/AbstractRouter.py
index 0e5f554342..598bbfeac9 100644
--- a/core/services/ardupilot_manager/mavlink_proxy/AbstractRouter.py
+++ b/core/services/ardupilot_manager/mavlink_proxy/AbstractRouter.py
@@ -94,6 +94,10 @@ def version(self) -> Optional[str]:
     def master_endpoint(self) -> Optional[Endpoint]:
         return self._master_endpoint
 
+    @master_endpoint.setter
+    def master_endpoint(self, master_endpoint: Endpoint) -> None:
+        self._master_endpoint = master_endpoint
+
     async def start(self, master_endpoint: Endpoint) -> None:
         self._master_endpoint = master_endpoint
         command = self.assemble_command(self._master_endpoint)
diff --git a/core/services/ardupilot_manager/mavlink_proxy/Manager.py b/core/services/ardupilot_manager/mavlink_proxy/Manager.py
index 3a0de47336..95317f3e4d 100644
--- a/core/services/ardupilot_manager/mavlink_proxy/Manager.py
+++ b/core/services/ardupilot_manager/mavlink_proxy/Manager.py
@@ -114,6 +114,10 @@ def _reset_endpoints(self) -> None:
     def master_endpoint(self) -> Optional[Endpoint]:
         return self.tool.master_endpoint
 
+    @master_endpoint.setter
+    def master_endpoint(self, master_endpoint: Endpoint) -> None:
+        self.tool.master_endpoint = master_endpoint
+
     async def start(self, master_endpoint: Endpoint) -> None:
         # If the tool is already running, don't start it again to avoid port conflicts
         if self.should_be_running and await self.is_running():
@@ -151,8 +155,10 @@ async def stop(self) -> None:
         self.should_be_running = False
         await self.tool.exit()
 
-    async def restart(self) -> None:
+    async def restart(self, master_endpoint: Optional[Endpoint] = None) -> None:
         self.should_be_running = False
+        if master_endpoint:
+            self.tool.master_endpoint = master_endpoint
         await self.tool.restart()
         self._last_valid_endpoints = self.endpoints()
         self.should_be_running = True
diff --git a/core/services/ardupilot_manager/typedefs.py b/core/services/ardupilot_manager/typedefs.py
index 94bcf03348..e5f7efd68c 100644
--- a/core/services/ardupilot_manager/typedefs.py
+++ b/core/services/ardupilot_manager/typedefs.py
@@ -97,6 +97,7 @@ class PlatformType(LowerStringEnum):
     Linux = auto()
     SITL = auto()
     Unknown = auto()
+    Manual = auto()
 
 
 class Platform(str, Enum):
@@ -113,6 +114,7 @@ class Platform(str, Enum):
     Navigator64 = "navigator64"
     Argonot = "argonot"
     SITL = get_sitl_platform_name(machine())
+    Manual = "Manual"
 
     @property
     def type(self) -> PlatformType:
@@ -127,6 +129,7 @@ def type(self) -> PlatformType:
             Platform.Navigator64: PlatformType.Linux,
             Platform.Argonot: PlatformType.Linux,
             Platform.SITL: PlatformType.SITL,
+            Platform.Manual: PlatformType.Manual,
         }
         return platform_types.get(self, PlatformType.Unknown)