Cracking Real-Time Updates on Shared Hosting-Our proven Approach
Real-Time Updates in a Shared Hosting Environment: How We Solved a Customer’s Challenge
Understanding the Customer’s Need
One of our customers, who runs a service-based business, needed real-time updates for customer requests submitted through their mobile app. Their staff used a Windows application to track and process these requests, and they wanted instant updates without manually refreshing the app.
However, there was a challenge. Their system was hosted on shared hosting, which meant:
- Frequent database queries could slow down performance.
- Hosting providers impose limits on remote database connections.
- Risk of account suspension if the database was queried too frequently.
We explored multiple solutions and implemented the best one based on their setup.
Initial Approach: Polling the Database (Not Ideal)
At first, we considered the simplest method: making the Windows app query the database every minute to check for new requests. This is called polling.
Why Polling Was a Problem
Inefficient – Queries run even when no new data is available.
Hosting Limitations – Too many queries can get the hosting account throttled or suspended.
Delayed Updates – If a request is added just after a query, the app won’t detect it until the next query cycle.
Polling was wasteful and unreliable, so we explored better alternatives.
Exploring Alternative Solutions
We considered three possible solutions:
- Firebase Cloud Messaging (FCM) – A push-based approach.
- WebSockets – A real-time communication method.
- A Web Service or Local Webpage Approach – Fetching updates efficiently.
Approach 1: Firebase Cloud Messaging (FCM) – Push-Based Updates
Firebase Cloud Messaging (FCM) is a Google-powered notification service that allows the server to send updates directly to the Windows app. Instead of checking the database repeatedly, the app simply waits for a notification.
How FCM Works
- The Windows app registers with Firebase to receive notifications.
- When a new customer request is submitted, the server triggers an FCM push notification.
- The Windows app receives the notification and fetches the new data only when needed.
Pros & Cons of FCM
Efficient – No constant database queries.
Real-time updates – Staff get notified instantly.
Works on Shared Hosting – Doesn’t rely on direct database connections.
Requires Internet Access – The app must be online to receive notifications.
Slight Delay – Push notifications may take a few seconds to arrive.
Approach 2: WebSockets – True Real-Time Communication
WebSockets provide a direct connection between the server and the Windows app, enabling instant updates without polling.
How WebSockets Work
- The Windows app connects to a WebSocket server.
- When a new request is submitted, the server pushes the update immediately.
Pros & Cons of WebSockets
Instant updates – No delay, unlike FCM.
No polling required – Saves server resources.
Not Supported on Shared Hosting – Most shared hosting providers do not allow WebSockets.
Requires a Separate Server – WebSockets need a dedicated Node.js server or a service like Pusher.
Since the customer was on shared hosting, WebSockets were not an option without upgrading their hosting plan.
Approach 3: Web Service or Local Webpage Approach
Another alternative was to create a web service (API) or a local webpage that runs on the customer’s Windows machine and fetches data from the database at regular intervals.
Option 1: A Local Webpage Running on Windows
Instead of having the Windows app directly connect to the database, we created a webpage in the shared hosting domain so that it will connect to the database locally:
- Runs on localhost (e.g.,
http://xxx.com/realtime-updates). - Fetches new customer requests from the hosted database.
- Displays the requests in real time using JavaScript AJAX.
How It Works
- The webpage uses JavaScript to fetch new data every few seconds from a lightweight PHP script hosted online.
- The Windows app loads this webpage inside an embedded browser control, keeping it up to date without making direct database queries.
Option 2: A Web Service API for the Windows App
We also considered setting up a PHP-based API on the shared hosting server, which:
- Returns only new customer requests (instead of querying the full database).
- Allows the Windows app to fetch updates efficiently without excessive queries.
The Windows app calls this API periodically and only fetches new data.
Pros & Cons of Web Service / Local Webpage Approach
More Efficient than Polling – Fetches only new data, reducing load.
Works on Shared Hosting – Doesn’t require WebSockets or FCM.
Can Work Offline (Local Webpage) – If cached properly.
Still Requires Periodic Requests – Not as real-time as FCM or WebSockets.
Slight Delay in Fetching Data – But configurable based on business needs.
Final Decision: Hybrid Approach for Maximum Efficiency
After evaluating all options, we implemented a hybrid approach:
✔ Firebase Cloud Messaging (FCM) for push notifications to Windows users.
✔ A Web Service API for efficient data retrieval when needed.
✔ A Local Webpage Option as a backup for real-time updates.
This approach ensured that:
- Staff get instant notifications (via FCM).
- The Windows app doesn’t overload the database (by using an API).
- A backup solution is available (local webpage) in case push notifications are delayed.
Conclusion
For customers on shared hosting, implementing real-time updates requires careful planning.
- Polling is inefficient and risky.
- WebSockets are great but require a dedicated server.
- FCM Push Notifications are the best choice for real-time updates.
- A Web Service or Local Webpage provides a good backup solution.
By combining these approaches, we delivered a reliable, real-time update system that worked within the limits of shared hosting.
If you need real-time updates for your own project, reach out to us, we would love to help!
Similar Posts : Cracking Real-Time Updates on Shared Hosting-Our proven Approach, See Also:Shared hosting realtime