diff --git a/sol/sol_context.cpp b/sol/sol_context.cpp
index 2dbdf60..7165c61 100644
--- a/sol/sol_context.cpp
+++ b/sol/sol_context.cpp
@@ -44,19 +44,26 @@
     if (enable)
     {
         auto bufferSize = sol::Manager::get().dataBuffer.size();
-        std::weak_ptr<Context> weakRef = weak_from_this();
         if (bufferSize > sendThreshold)
         {
-            getIo()->post([weakRef]() {
-                std::shared_ptr<Context> self = weakRef.lock();
-                if (self)
+            try
+            {
+                int rc = sendOutboundPayload();
+                if (rc == 0)
                 {
-                    self->charAccTimerHandler();
+                    return;
                 }
-            });
-            return;
+            }
+            catch (const std::exception& e)
+            {
+                lg2::error(
+                    "Failed to call the sendOutboundPayload method: {ERROR}",
+                    "ERROR", e);
+                return;
+            }
         }
         accumulateTimer.expires_after(interval);
+        std::weak_ptr<Context> weakRef = weak_from_this();
         accumulateTimer.async_wait(
             [weakRef](const boost::system::error_code& ec) {
             std::shared_ptr<Context> self = weakRef.lock();
@@ -250,7 +257,6 @@
 {
     if (payloadCache.size() != 0)
     {
-        enableAccumulateTimer(true);
         return -1;
     }
 
