diff --git a/esphome/components/ezo/ezo.h b/esphome/components/ezo/ezo.h
index f1a2802cbd..d80869fbd9 100644
--- a/esphome/components/ezo/ezo.h
+++ b/esphome/components/ezo/ezo.h
@@ -44,8 +44,8 @@ class EZOSensor : public sensor::Sensor, public PollingComponent, public i2c::I2
 
   // Device Information
   void get_device_information();
-  void add_device_infomation_callback(std::function<void(std::string)> &&callback) {
-    this->device_infomation_callback_.add(std::move(callback));
+  template<typename F> void add_device_infomation_callback(F &&callback) {
+    this->device_infomation_callback_.add(std::forward<F>(callback));
   }
 
   // Sleep
@@ -56,15 +56,13 @@ class EZOSensor : public sensor::Sensor, public PollingComponent, public i2c::I2
 
   // Slope
   void get_slope();
-  void add_slope_callback(std::function<void(std::string)> &&callback) {
-    this->slope_callback_.add(std::move(callback));
-  }
+  template<typename F> void add_slope_callback(F &&callback) { this->slope_callback_.add(std::forward<F>(callback)); }
 
   // T
   void get_t();
   void set_t(float value);
   void set_tempcomp_value(float temp);  // For backwards compatibility
-  void add_t_callback(std::function<void(std::string)> &&callback) { this->t_callback_.add(std::move(callback)); }
+  template<typename F> void add_t_callback(F &&callback) { this->t_callback_.add(std::forward<F>(callback)); }
 
   // Calibration
   void get_calibration();
@@ -73,20 +71,18 @@ class EZOSensor : public sensor::Sensor, public PollingComponent, public i2c::I2
   void set_calibration_point_high(float value);
   void set_calibration_generic(float value);
   void clear_calibration();
-  void add_calibration_callback(std::function<void(std::string)> &&callback) {
-    this->calibration_callback_.add(std::move(callback));
+  template<typename F> void add_calibration_callback(F &&callback) {
+    this->calibration_callback_.add(std::forward<F>(callback));
   }
 
   // LED
   void get_led_state();
   void set_led_state(bool on);
-  void add_led_state_callback(std::function<void(bool)> &&callback) { this->led_callback_.add(std::move(callback)); }
+  template<typename F> void add_led_state_callback(F &&callback) { this->led_callback_.add(std::forward<F>(callback)); }
 
   // Custom
   void send_custom(const std::string &to_send);
-  void add_custom_callback(std::function<void(std::string)> &&callback) {
-    this->custom_callback_.add(std::move(callback));
-  }
+  template<typename F> void add_custom_callback(F &&callback) { this->custom_callback_.add(std::forward<F>(callback)); }
 
  protected:
   std::deque<std::unique_ptr<EzoCommand>> commands_;
diff --git a/esphome/components/haier/haier_base.cpp b/esphome/components/haier/haier_base.cpp
index 1882aa439e..35eaf36d32 100644
--- a/esphome/components/haier/haier_base.cpp
+++ b/esphome/components/haier/haier_base.cpp
@@ -197,10 +197,6 @@ void HaierClimateBase::send_custom_command(const haier_protocol::HaierMessage &m
   this->action_request_ = PendingAction({ActionRequest::SEND_CUSTOM_COMMAND, message});
 }
 
-void HaierClimateBase::add_status_message_callback(std::function<void(const char *, size_t)> &&callback) {
-  this->status_message_callback_.add(std::move(callback));
-}
-
 haier_protocol::HandlerError HaierClimateBase::answer_preprocess_(
     haier_protocol::FrameType request_message_type, haier_protocol::FrameType expected_request_message_type,
     haier_protocol::FrameType answer_message_type, haier_protocol::FrameType expected_answer_message_type,
diff --git a/esphome/components/haier/haier_base.h b/esphome/components/haier/haier_base.h
index e24217bfd9..87aa1d65ef 100644
--- a/esphome/components/haier/haier_base.h
+++ b/esphome/components/haier/haier_base.h
@@ -74,7 +74,9 @@ class HaierClimateBase : public esphome::Component,
   void set_answer_timeout(uint32_t timeout);
   void set_send_wifi(bool send_wifi);
   void send_custom_command(const haier_protocol::HaierMessage &message);
-  void add_status_message_callback(std::function<void(const char *, size_t)> &&callback);
+  template<typename F> void add_status_message_callback(F &&callback) {
+    this->status_message_callback_.add(std::forward<F>(callback));
+  }
 
  protected:
   enum class ProtocolPhases {
diff --git a/esphome/components/haier/hon_climate.cpp b/esphome/components/haier/hon_climate.cpp
index b8889ef2bd..b7888f7976 100644
--- a/esphome/components/haier/hon_climate.cpp
+++ b/esphome/components/haier/hon_climate.cpp
@@ -114,14 +114,6 @@ void HonClimate::start_steri_cleaning() {
   }
 }
 
-void HonClimate::add_alarm_start_callback(std::function<void(uint8_t, const char *)> &&callback) {
-  this->alarm_start_callback_.add(std::move(callback));
-}
-
-void HonClimate::add_alarm_end_callback(std::function<void(uint8_t, const char *)> &&callback) {
-  this->alarm_end_callback_.add(std::move(callback));
-}
-
 haier_protocol::HandlerError HonClimate::get_device_version_answer_handler_(haier_protocol::FrameType request_type,
                                                                             haier_protocol::FrameType message_type,
                                                                             const uint8_t *data, size_t data_size) {
diff --git a/esphome/components/haier/hon_climate.h b/esphome/components/haier/hon_climate.h
index 9bddac3f92..7c48a3748b 100644
--- a/esphome/components/haier/hon_climate.h
+++ b/esphome/components/haier/hon_climate.h
@@ -124,8 +124,12 @@ class HonClimate : public HaierClimateBase {
   void set_extra_sensors_packet_bytes_size(size_t size) { this->extra_sensors_packet_bytes_ = size; };
   void set_status_message_header_size(size_t size) { this->status_message_header_size_ = size; };
   void set_control_method(HonControlMethod method) { this->control_method_ = method; };
-  void add_alarm_start_callback(std::function<void(uint8_t, const char *)> &&callback);
-  void add_alarm_end_callback(std::function<void(uint8_t, const char *)> &&callback);
+  template<typename F> void add_alarm_start_callback(F &&callback) {
+    this->alarm_start_callback_.add(std::forward<F>(callback));
+  }
+  template<typename F> void add_alarm_end_callback(F &&callback) {
+    this->alarm_end_callback_.add(std::forward<F>(callback));
+  }
   float get_active_alarm_count() const { return this->active_alarm_count_; }
 
  protected:
diff --git a/esphome/components/hlk_fm22x/hlk_fm22x.h b/esphome/components/hlk_fm22x/hlk_fm22x.h
index adef49a2d8..d897d51881 100644
--- a/esphome/components/hlk_fm22x/hlk_fm22x.h
+++ b/esphome/components/hlk_fm22x/hlk_fm22x.h
@@ -100,9 +100,8 @@ class HlkFm22xComponent : public PollingComponent, public uart::UARTDevice {
   template<typename F> void add_on_face_scan_invalid_callback(F &&callback) {
     this->face_scan_invalid_callback_.add(std::forward<F>(callback));
   }
-  void add_on_face_info_callback(
-      std::function<void(int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t, int16_t)> callback) {
-    this->face_info_callback_.add(std::move(callback));
+  template<typename F> void add_on_face_info_callback(F &&callback) {
+    this->face_info_callback_.add(std::forward<F>(callback));
   }
   template<typename F> void add_on_enrollment_done_callback(F &&callback) {
     this->enrollment_done_callback_.add(std::forward<F>(callback));
diff --git a/esphome/components/microphone/microphone.cpp b/esphome/components/microphone/microphone.cpp
index 0fbb393fd2..c941e9c3ac 100644
--- a/esphome/components/microphone/microphone.cpp
+++ b/esphome/components/microphone/microphone.cpp
@@ -1,19 +1 @@
-#include "microphone.h"
-
-namespace esphome {
-namespace microphone {
-
-void Microphone::add_data_callback(std::function<void(const std::vector<uint8_t> &)> &&data_callback) {
-  std::function<void(const std::vector<uint8_t> &)> mute_handled_callback =
-      [this, data_callback](const std::vector<uint8_t> &data) {
-        if (this->mute_state_) {
-          data_callback(std::vector<uint8_t>(data.size(), 0));
-        } else {
-          data_callback(data);
-        };
-      };
-  this->data_callbacks_.add(std::move(mute_handled_callback));
-}
-
-}  // namespace microphone
-}  // namespace esphome
+// Intentionally empty - all methods are now inline templates in microphone.h
diff --git a/esphome/components/microphone/microphone.h b/esphome/components/microphone/microphone.h
index fcf9822458..57025564ac 100644
--- a/esphome/components/microphone/microphone.h
+++ b/esphome/components/microphone/microphone.h
@@ -22,7 +22,17 @@ class Microphone {
  public:
   virtual void start() = 0;
   virtual void stop() = 0;
-  void add_data_callback(std::function<void(const std::vector<uint8_t> &)> &&data_callback);
+  template<typename F> void add_data_callback(F &&data_callback) {
+    std::function<void(const std::vector<uint8_t> &)> mute_handled_callback =
+        [this, data_callback](const std::vector<uint8_t> &data) {
+          if (this->mute_state_) {
+            data_callback(std::vector<uint8_t>(data.size(), 0));
+          } else {
+            data_callback(data);
+          };
+        };
+    this->data_callbacks_.add(std::move(mute_handled_callback));
+  }
 
   bool is_running() const { return this->state_ == STATE_RUNNING; }
   bool is_stopped() const { return this->state_ == STATE_STOPPED; }
diff --git a/esphome/components/microphone/microphone_source.cpp b/esphome/components/microphone/microphone_source.cpp
index 00efcf22a1..fb4ebc4a04 100644
--- a/esphome/components/microphone/microphone_source.cpp
+++ b/esphome/components/microphone/microphone_source.cpp
@@ -6,24 +6,6 @@ namespace microphone {
 static const int32_t Q25_MAX_VALUE = (1 << 25) - 1;
 static const int32_t Q25_MIN_VALUE = ~Q25_MAX_VALUE;
 
-void MicrophoneSource::add_data_callback(std::function<void(const std::vector<uint8_t> &)> &&data_callback) {
-  std::function<void(const std::vector<uint8_t> &)> filtered_callback =
-      [this, data_callback](const std::vector<uint8_t> &data) {
-        if (this->enabled_ || this->passive_) {
-          if (this->processed_samples_.use_count() == 0) {
-            // Create vector if its unused
-            this->processed_samples_ = std::make_shared<std::vector<uint8_t>>();
-          }
-
-          // Take temporary ownership of samples vector to avoid deallaction before the callback finishes
-          std::shared_ptr<std::vector<uint8_t>> output_samples = this->processed_samples_;
-          this->process_audio_(data, *output_samples);
-          data_callback(*output_samples);
-        }
-      };
-  this->mic_->add_data_callback(std::move(filtered_callback));
-}
-
 audio::AudioStreamInfo MicrophoneSource::get_audio_stream_info() {
   return audio::AudioStreamInfo(this->bits_per_sample_, this->channels_.count(),
                                 this->mic_->get_audio_stream_info().get_sample_rate());
diff --git a/esphome/components/microphone/microphone_source.h b/esphome/components/microphone/microphone_source.h
index 1e81a284b6..eb45bb2bed 100644
--- a/esphome/components/microphone/microphone_source.h
+++ b/esphome/components/microphone/microphone_source.h
@@ -47,7 +47,23 @@ class MicrophoneSource {
   /// @param channel 0-indexed channel number to enable
   void add_channel(uint8_t channel) { this->channels_.set(channel); }
 
-  void add_data_callback(std::function<void(const std::vector<uint8_t> &)> &&data_callback);
+  template<typename F> void add_data_callback(F &&data_callback) {
+    std::function<void(const std::vector<uint8_t> &)> filtered_callback =
+        [this, data_callback](const std::vector<uint8_t> &data) {
+          if (this->enabled_ || this->passive_) {
+            if (this->processed_samples_.use_count() == 0) {
+              // Create vector if its unused
+              this->processed_samples_ = std::make_shared<std::vector<uint8_t>>();
+            }
+
+            // Take temporary ownership of samples vector to avoid deallaction before the callback finishes
+            std::shared_ptr<std::vector<uint8_t>> output_samples = this->processed_samples_;
+            this->process_audio_(data, *output_samples);
+            data_callback(*output_samples);
+          }
+        };
+    this->mic_->add_data_callback(std::move(filtered_callback));
+  }
 
   void set_gain_factor(int32_t gain_factor) { this->gain_factor_ = clamp<int32_t>(gain_factor, 1, MAX_GAIN_FACTOR); }
   int32_t get_gain_factor() { return this->gain_factor_; }
diff --git a/esphome/components/nextion/nextion.cpp b/esphome/components/nextion/nextion.cpp
index 01ceb3d765..85da6af48a 100644
--- a/esphome/components/nextion/nextion.cpp
+++ b/esphome/components/nextion/nextion.cpp
@@ -214,30 +214,6 @@ void Nextion::update() {
   }
 }
 
-void Nextion::add_sleep_state_callback(std::function<void()> &&callback) {
-  this->sleep_callback_.add(std::move(callback));
-}
-
-void Nextion::add_wake_state_callback(std::function<void()> &&callback) {
-  this->wake_callback_.add(std::move(callback));
-}
-
-void Nextion::add_setup_state_callback(std::function<void()> &&callback) {
-  this->setup_callback_.add(std::move(callback));
-}
-
-void Nextion::add_new_page_callback(std::function<void(uint8_t)> &&callback) {
-  this->page_callback_.add(std::move(callback));
-}
-
-void Nextion::add_touch_event_callback(std::function<void(uint8_t, uint8_t, bool)> &&callback) {
-  this->touch_callback_.add(std::move(callback));
-}
-
-void Nextion::add_buffer_overflow_event_callback(std::function<void()> &&callback) {
-  this->buffer_overflow_callback_.add(std::move(callback));
-}
-
 void Nextion::update_all_components() {
   if ((!this->is_setup() && !this->connection_state_.ignore_is_setup_) || this->is_sleeping())
     return;
diff --git a/esphome/components/nextion/nextion.h b/esphome/components/nextion/nextion.h
index 7999e3c4e3..2842e57ce8 100644
--- a/esphome/components/nextion/nextion.h
+++ b/esphome/components/nextion/nextion.h
@@ -1138,37 +1138,47 @@ class Nextion : public NextionBase, public PollingComponent, public uart::UARTDe
    *
    * @param callback The void() callback.
    */
-  void add_sleep_state_callback(std::function<void()> &&callback);
+  template<typename F> void add_sleep_state_callback(F &&callback) {
+    this->sleep_callback_.add(std::forward<F>(callback));
+  }
 
   /** Add a callback to be notified of wake state changes.
    *
    * @param callback The void() callback.
    */
-  void add_wake_state_callback(std::function<void()> &&callback);
+  template<typename F> void add_wake_state_callback(F &&callback) {
+    this->wake_callback_.add(std::forward<F>(callback));
+  }
 
   /** Add a callback to be notified when the nextion completes its initialize setup.
    *
    * @param callback The void() callback.
    */
-  void add_setup_state_callback(std::function<void()> &&callback);
+  template<typename F> void add_setup_state_callback(F &&callback) {
+    this->setup_callback_.add(std::forward<F>(callback));
+  }
 
   /** Add a callback to be notified when the nextion changes pages.
    *
    * @param callback The void(std::string) callback.
    */
-  void add_new_page_callback(std::function<void(uint8_t)> &&callback);
+  template<typename F> void add_new_page_callback(F &&callback) { this->page_callback_.add(std::forward<F>(callback)); }
 
   /** Add a callback to be notified when Nextion has a touch event.
    *
    * @param callback The void() callback.
    */
-  void add_touch_event_callback(std::function<void(uint8_t, uint8_t, bool)> &&callback);
+  template<typename F> void add_touch_event_callback(F &&callback) {
+    this->touch_callback_.add(std::forward<F>(callback));
+  }
 
   /** Add a callback to be notified when the nextion reports a buffer overflow.
    *
    * @param callback The void() callback.
    */
-  void add_buffer_overflow_event_callback(std::function<void()> &&callback);
+  template<typename F> void add_buffer_overflow_event_callback(F &&callback) {
+    this->buffer_overflow_callback_.add(std::forward<F>(callback));
+  }
 
   void update_all_components();
 
diff --git a/esphome/components/speaker/speaker.h b/esphome/components/speaker/speaker.h
index 373d2e3a74..5b89d00c69 100644
--- a/esphome/components/speaker/speaker.h
+++ b/esphome/components/speaker/speaker.h
@@ -106,8 +106,8 @@ class Speaker {
   /// Parameters:
   ///   - Frames played
   ///   - System time in microseconds when the frames were written to the DAC
-  void add_audio_output_callback(std::function<void(uint32_t, int64_t)> &&callback) {
-    this->audio_output_callback_.add(std::move(callback));
+  template<typename F> void add_audio_output_callback(F &&callback) {
+    this->audio_output_callback_.add(std::forward<F>(callback));
   }
 
  protected:
diff --git a/esphome/components/uart/uart_component.h b/esphome/components/uart/uart_component.h
index 853de719fe..ee2b006039 100644
--- a/esphome/components/uart/uart_component.h
+++ b/esphome/components/uart/uart_component.h
@@ -190,9 +190,7 @@ class UARTComponent {
 #endif  // USE_ESP8266 || USE_ESP32
 
 #ifdef USE_UART_DEBUGGER
-  void add_debug_callback(std::function<void(UARTDirection, uint8_t)> &&callback) {
-    this->debug_callback_.add(std::move(callback));
-  }
+  template<typename F> void add_debug_callback(F &&callback) { this->debug_callback_.add(std::forward<F>(callback)); }
 #endif
 
  protected:
diff --git a/esphome/components/zigbee/zigbee_zephyr.h b/esphome/components/zigbee/zigbee_zephyr.h
index dcc2b40a16..3fa5818ec5 100644
--- a/esphome/components/zigbee/zigbee_zephyr.h
+++ b/esphome/components/zigbee/zigbee_zephyr.h
@@ -74,7 +74,7 @@ class ZigbeeComponent : public Component {
     // endpoints are enumerated from 1
     this->callbacks_[endpoint - 1] = std::move(cb);
   }
-  void add_join_callback(std::function<void()> &&cb) { this->join_cb_.add(std::move(cb)); }
+  template<typename F> void add_join_callback(F &&cb) { this->join_cb_.add(std::forward<F>(cb)); }
   void zboss_signal_handler_esphome(zb_bufid_t bufid);
   void factory_reset();
   Trigger<> *get_join_trigger() { return &this->join_trigger_; };