Our founder, Michael St. Clair, recently presented at ElixirConf US on practical techniques for building fast, interactive applications using LiveView.
The session focused on performance optimization, real-time synchronization, and modern frontend patterns — the kinds of architectural decisions that determine whether systems feel responsive, reliable, and scalable.
These lessons apply far beyond LiveView. Any team building operational tooling, dashboards, or database-driven systems faces the same core challenges — especially teams working to streamline database access management or manage complex infrastructure across environments. These are the same operational problems we designed QueryDesk to solve:
- keeping interfaces responsive
- synchronizing data safely
- maintaining performance under load
Below are the key ideas from the session, followed by the full recording and transcript.
The Three Core Ideas from the Talk
1) Optimize the User Experience by Reducing Diff Sizes
Performance isn't just about speed.
It's about responsiveness.
Teams often ask how to speed up SQL queries in production systems, but performance improvements usually come from better architecture, better workflows, and better visibility across the database query platform.
In LiveView applications, updates are sent as diffs — changes to the DOM — rather than full page reloads. But those diffs can still grow large if components are not structured carefully.
A few practical patterns make a significant difference:
- Break large components into smaller ones
- Minimize unnecessary re-renders
- Send only the data that actually changed
- Be intentional about component boundaries
Small architectural decisions compound quickly.
They determine whether an application feels instant — or sluggish.
2) Use Database Replication to Keep Interfaces in Sync
One of the most interesting techniques discussed in the session was using Postgres replication to automatically push updates to connected LiveViews.
This type of real-time synchronization is increasingly common in environments using database version control and modern DevOps database automation tools, where teams need consistent state across services without introducing operational risk.
Instead of polling for changes, the system reacts to them.
This pattern is especially useful for:
- dashboards
- monitoring systems
- administrative tooling
- collaborative workflows
When the database changes, the interface updates immediately.
No refresh required.
No polling logic.
No synchronization code.
Just consistent state.
3) Enhance the Frontend — Intentionally
LiveView handles most interactivity well on its own.
But sometimes the user experience benefits from additional frontend behavior.
That's where hooks, web components, and JavaScript come in.
These tools allow teams to:
- integrate third-party libraries
- add animation and visual feedback
- support complex user interactions
- extend functionality without rewriting the system
The key idea is restraint.
Use additional tools when they improve the experience — not simply because they exist.
Watch the Full Talk
Curious how teams apply these patterns to real database operations?
You can try QueryDesk yourself in minutes.
Why These Patterns Matter
Most systems fail slowly.
Not because of a single bug — but because small inefficiencies accumulate.
As systems scale, teams often struggle with fragmented credentials, duplicated tooling, and inconsistent workflows. Many organizations move toward database access consolidation to reduce risk, simplify operations, and improve visibility across environments.
Large components.
Unnecessary updates.
Polling loops.
Manual synchronization logic.
Over time, those decisions create friction.
The patterns in this talk address those problems directly.
They make systems:
- faster
- simpler
- more predictable
- easier to operate
These are exactly the types of operational guardrails and workflow automation patterns built into QueryDesk workflows and approval systems - the kind of capabilities typically found in modern database security software designed to protect production environments.
And those outcomes matter whether you're building a customer-facing application or an internal developer tool.
Want to See These Patterns in Production?
QueryDesk helps teams safely manage database operations, automate workflows, and maintain real-time visibility across systems — using schema-aware AI to enforce guardrails and reduce risk without slowing developers down.
You can try it immediately.
No complicated setup.
No waiting for approvals.
Full Transcript
Hi everyone, my name is Michael St. Clair.
Today I’m going to share some tips and tricks that I’ve learned over the past few years while building applications using LiveView.
This talk is really focused on practical things — things that I’ve discovered through experience — that help improve performance, improve the developer experience, and help you build more interactive applications.
We’re going to look at three main areas today:
First, optimizations that improve the user experience.
Second, a library that I built called live_sync.
And third, how to use hooks, web components, and JavaScript to enhance the frontend experience.
Optimizing the User Experience
One of the biggest lessons I’ve learned while building LiveView applications is that performance matters — especially when it comes to perceived performance.
Users don’t necessarily measure performance in milliseconds.
They measure performance in how responsive the application feels.
So one of the key areas to focus on is reducing diff sizes.
When LiveView sends updates to the client, it sends diffs — changes to the DOM — rather than the entire page.
But those diffs can still become large if you’re not careful.
There are a few strategies that can help with this.
One is minimizing the amount of data you send to the client.
Another is being thoughtful about how you structure your components.
For example, breaking large components into smaller ones can reduce the amount of data that needs to be updated when something changes.
You also want to be careful about unnecessary re-renders.
Sometimes a component will update even when the data hasn’t actually changed.
That creates extra work for both the server and the client.
So paying attention to when and why components update can have a big impact on performance.
Introducing live_sync
The second topic I want to talk about is a library that I built called live_sync.
This library was inspired by a talk from José Valim last year, where he demonstrated how Postgres replication could be used to keep applications in sync.
I wanted to explore how that idea could be applied to LiveView.
So live_sync uses Postgres replication to automatically push updates to connected LiveViews.
That means when data changes in the database, the UI can update immediately — without polling and without manual refresh logic.
This can be especially useful for dashboards, monitoring tools, and collaborative applications.
Instead of constantly checking for changes, the application simply reacts when changes happen.
That leads to better performance and a more responsive user experience.
It also simplifies your application logic.
You don’t need to write custom synchronization code.
The system handles it for you.
Enhancing the Frontend with Hooks and Web Components
The third area I want to talk about is enhancing the frontend experience.
LiveView is powerful on its own, but sometimes you need additional interactivity.
That’s where hooks, web components, and JavaScript come in.
Hooks allow you to attach JavaScript behavior to LiveView components.
This makes it possible to integrate third-party libraries, add animations, or handle complex user interactions.
Web components are another useful tool.
They allow you to create reusable UI elements that work across different parts of your application.
And JavaScript can fill in the gaps where LiveView alone might not be enough.
The key is to use these tools thoughtfully.
You don’t want to overcomplicate your application.
But when used correctly, they can significantly improve the user experience.
Key Takeaways
If there’s one thing I want you to take away from this talk, it’s this:
Focus on the user experience.
Optimize performance.
Keep your components small and efficient.
Use tools like Postgres replication to keep data synchronized.
And enhance the frontend where it makes sense.
LiveView makes it possible to build fast, interactive applications with relatively little complexity.
But like any tool, it works best when you understand how to use it effectively.
Thank you.