{"id":1945,"date":"2026-10-25T07:52:10","date_gmt":"2026-10-25T07:52:10","guid":{"rendered":"https:\/\/blogs.bragly.io\/what-does-auto-sync-do\/"},"modified":"2026-10-25T07:53:04","modified_gmt":"2026-10-25T07:53:04","slug":"what-does-auto-sync-do","status":"publish","type":"post","link":"https:\/\/blogs.bragly.io\/what-does-auto-sync-do\/","title":{"rendered":"What Does Auto Sync Do? How Reviews Stay Current"},"content":{"rendered":"

Auto-sync automatically checks connected sources and refreshes the copy your site shows, without anyone pressing an update button. The refresh happens on a schedule<\/strong> or when an event<\/strong> fires, not necessarily instantly.<\/p>\n

So if it's automatic, why can a review you can already see on Google still be missing from your website? That gap is where most owners get confused. Automatic<\/strong> describes who starts the work. It doesn't promise when the work finishes, or that it can fetch something you never connected.<\/p>\n

What Auto-Sync Does and Why Your Widgets Need It<\/h2>\n

Auto-sync repeatedly checks connected sources and refreshes the copy your website displays, with no update button to press.<\/p>\n

Think of a shared shopping list on your phone. Someone at home adds milk, and the list on your phone updates in the shop. Nobody has to text you, screenshot the list, or retype it. The app checks, finds the change, and updates the copy you're looking at.<\/p>\n

\"A<\/figure><\/p>\n

Reviews work the same way. You connect a source such as Google or Trustpilot once. From then on, the system checks that source for you, and your testimonial widgets<\/a> reflect new, edited, or removed reviews<\/strong> instead of whatever a staff member copied across months ago.<\/p>\n

Manual Updating Compared With Auto-Sync<\/h3>\n\n
\n\n\n\n\n
Question<\/th>\nManual Updating<\/th>\nAuto-Sync<\/th>\n<\/tr>\n
Who starts the refresh?<\/td>\nA person remembers to do it<\/td>\nThe system, on its schedule<\/td>\n<\/tr>\n
Staff effort per source<\/td>\nCopy, paste, and format each review<\/td>\nConnect once, then check status<\/td>\n<\/tr>\n
How failures show up<\/td>\nOften nobody notices for weeks<\/td>\nA last-sync time<\/strong> or error status<\/td>\n<\/tr>\n
How current it stays<\/td>\nOnly as current as the last copy job<\/td>\nRefreshed at each check<\/td>\n<\/tr>\n<\/table><\/figure>\n
\n

Auto-sync removes the repetitive copying. It doesn't remove the delay between checks.<\/p>\n<\/blockquote>\n

That's the honest trade. Your widget stays close to the source without a weekly task, but a review published two minutes ago may not appear until the next check runs. Expect maintenance that runs itself, not instant publishing.<\/p>\n

How Auto-Sync Checks Sources and Updates Widgets<\/h2>\n

A review can change at its source while your widget still shows the earlier version. Auto-sync checks for those changes, processes them, and refreshes the widget. The process depends on the source connection and its permissions.<\/p>\n

    \n
  1. Connect:<\/strong> The system saves which source to check and the permissions you granted. Those permissions determine what information it can access.<\/li>\n
  2. Check:<\/strong> The system learns about changes by asking the source at intervals, receiving event notifications, or using both methods.<\/li>\n
  3. Match:<\/strong> It uses a stable identifier, a fixed ID for each review, to match incoming information with the right review and avoid duplicates.<\/li>\n
  4. Apply:<\/strong> It adds new reviews and updates or removes existing ones in the stored records.<\/li>\n
  5. Refresh:<\/strong> The widget displays the latest available records, and the system saves a last-sync time you can check.<\/li>\n<\/ol>\n

    \"A<\/figure><\/p>\n

    Three Ways to Learn Something Changed<\/h3>\n

    The second step can use polling, webhooks, or a combination of both. These methods differ in how quickly changes may appear, how many requests reach the source, and what happens when a check or notification fails.<\/p>\n

    Polling<\/strong> works like checking a mailbox on a schedule. The system asks the source for changes since its last check. Webhooks<\/strong> work like delivery alerts: the source sends a notification when a record changes. A hybrid<\/strong> method uses notifications for speed and scheduled checks to look for changes the notifications might have missed.<\/p>\n\n

    \n\n\n\n
    Method<\/th>\nHow It Learns of Changes<\/th>\nFreshness<\/th>\nLoad on Source<\/th>\nFailure Behavior<\/th>\n<\/tr>\n
    Polling<\/td>\nAsks the source at intervals for changes since the last saved point<\/td>\nChanges may wait until the next check<\/td>\nSends requests even when nothing has changed<\/td>\nA later check may find changes missed by an earlier one<\/td>\n<\/tr>\n
    Webhooks<\/td>\nSource sends a notification when a record changes<\/td>\nNotifications can arrive quickly, but delivery is not guaranteed<\/td>\nSends notifications when changes occur<\/td>\nA failed notification may delay an update or require another delivery attempt<\/td>\n<\/tr>\n
    Hybrid<\/td>\nUses notifications and scheduled checks<\/td>\nNotifications can be quick; scheduled checks can catch gaps<\/td>\nIncludes both notifications and periodic requests<\/td>\nA later check may find changes a notification missed<\/td>\n<\/tr>\n<\/table><\/figure>\n

    Each method has a different trade-off. Polling can leave a delay between checks. Webhooks can reduce that delay, but a notification may fail to arrive. Combining the methods can provide a backup check, though it also means the system still needs permission to access the source.<\/p>\n

    To check freshness, compare when a review appears at the source with when it appears on your page. For example, you could set a target that 95% of changes appear within 15 minutes. That is a target to measure, not a guaranteed result.<\/p>\n

    \n

    Practical rule:<\/strong> Judge freshness by the time between a change at the source and its appearance on your page, not only by whether a sync request succeeded.<\/p>\n<\/blockquote>\n

    Review the connected source integrations<\/a> to see which sources your pages rely on and what permissions they require. A sync can only update information it is allowed to access.<\/p>\n

    What Reaches Your Widgets and What Auto-Sync Cannot Do<\/h2>\n

    Start with a deletion, because that surprises owners most. A restaurant flags a spam review on Google. The platform removes it. After the next sync, that same review disappears from the restaurant's website widget too.<\/p>\n

    Nobody deleted it from the website. The sync just did its job, which is keeping your copy matched to the source.<\/p>\n

    Changes a Sync Carries Across<\/h3>\n