We can clearly see that, in the last year, Google focused mostly on supporting user experience and performance. We can see that in Google AMP websites focused on lighting fast performance, Single Page Apps (SPA), or Progressive Web Apps.
Unfortunately, in practice, this doesn’t always work and requires complex debugging to fix. On top of that, it’s yet another piece of the application stack to maintain, and there may be compatibility issues with your application, causing the caught HTML output to be incorrect. This is an issue because it may be hard to notice any resulting SEO problems until it’s too late and your rankings are affected.
As you can see, it can all get quite complicated.
How Does It Work?
Thanks to this feature, you can feed your application with some data coming from the database on the server, run it, and capture the resulting HTML output that would normally require a browser to assemble. This output can then be served as your initial HTML to everyone who requests it (including crawlers, such as the Google Bot).
Your application can then use this HTML as a base for itself and continue operating on it in the browser as if it were rendered by the browser in the first place.
Benefits of Isomorphic Applications
Search Engine Indexability
Isomorphic applications solve this problem by executing code on the server to render static pages and then leaving all the JS responsible for user interactions to be run by the browser (user).
As a result, the crawler sees the exact same output the browser sees, which completely solves the SEO indexing problem. All the content is rendered and it is there when a search engine accesses the page.
Perceived Load Time is Faster
Downloading JS-heavy code can take some time, especially in areas with a slower internet connection. Rendering all the downloaded code to DOM, then waiting for the app/website to bootstrap and perform initial AJAX requests also takes a while. This often leads to a slow initial load of the website or application, unhappy users, and a lowering of the website’s income. Fortunately, the isomorphic approach solves part of this problem.
By rendering application markup on the server-side, there is no need for the majority of AJAX calls and there is less rendering happening on the client side (due to initial rendering on the server). This decreases perceived load time by around 40%.
There’s No Such Thing As a Free Lunch
As this famous saying suggests — nothing comes for free. The isomorphic approach is great since it solves the SEO indexing problems, results in faster load times, and simplifies the application stack (as compared to using pre-rendering services). Also, it can bring benefits for large code bases (easier to maintain, client and server code get separated, etc.). However, it comes at a price.
You Are Forced to Use Certain Technologies
All this means is that this approach is not very well-suited for existing projects, as it’s not a plug-and-play solution. It can work well with existing applications if they rely heavily on the APIs, yet would still require a significant amount of work to implement.
You Need Expertise
This is still a fairly new approach, very different from the older ones (e.g. the server-side rendering/jQuery mix), that requires cutting edge technology. As a result, you need developers who are up for the job and are comfortable working with these new technologies; developers who are not afraid to experiment and get their hands dirty.
Sometimes the ready-made libraries don’t play well together, sometimes you need to solve problems yourself, and you need the necessary experience to get the application to the finish line.
While the isomorphic approach is not yet widely popular, it’s gaining a lot of traction. At this point, it’s probably the best way to build a large, dynamic application that requires great, smooth user experience while not compromising on SEO.
It’s probably not a great idea for small projects because it requires a lot of engineering and experience to get right, but this will get easier over time as new libraries and tools are developed that take care of the more complex parts of the process.
Overall, it’s a very promising way of solving the SEO indexing problem that’s been bugging the community for years. If you’re building a new, large application that requires great SEO compatibility, you should definitely consider it.
SEOs & Developers