Architecture
Inside Lixcel: A Modern Architecture Designed for Speed, Flexibility, and Scale
How Lixcel combines configuration-driven rendering, modern web technologies, and flexible storage.
Every software platform eventually faces the same challenge:
How do you build applications that are simple enough for beginners, yet powerful enough for businesses?
Lixcel was designed from the ground up to answer that question.
Its architecture combines modern web technologies with a flexible storage model, AI integration, and automatic UI generation.
A Configuration-Driven Rendering Engine
The heart of Lixcel is its rendering engine.
Instead of storing screen layouts, every application stores its configuration.
This includes:
- lists
- fields
- relationships
- data types
- permissions
- display preferences
The React frontend interprets this configuration and automatically renders the appropriate interface.
This makes applications:
- easier to maintain
- smaller to store
- faster to generate
- consistent across devices
React Frontend
Lixcel’s user interface is built using React.
React provides:
- fast rendering
- reusable components
- responsive layouts
- progressive web app (PWA) support
Because the interface is generated dynamically, improvements made to the rendering engine immediately benefit every application built on the platform.
ASP.NET Core Backend
The backend is implemented using ASP.NET Core.
Its responsibilities include:
- authentication
- authorization
- API endpoints
- cloud synchronization
- AI services
- storage routing
- application publishing
Keeping the rendering logic on the client while the backend focuses on services allows the platform to scale efficiently.
Multiple Storage Strategies
Not every application needs the same persistence model.
Lixcel supports three different approaches.
Relational Database
Business applications can store structured data in SQL databases.
Only modified rows are transmitted to the server, reducing bandwidth and improving performance.
This approach works well for:
- CRM systems
- inventory management
- issue tracking
- customer databases
Azure Cosmos DB
Applications can also be stored as complete JSON documents.
This is ideal for:
- personal applications
- templates
- portable projects
- document-oriented data
Azure Blob Storage
For lightweight scenarios, entire applications can be stored as JSON files in Azure Blob Storage.
This minimizes storage costs while maintaining excellent scalability.
Smart Synchronization
Rather than sending an application’s entire dataset every time a user clicks Save, Lixcel tracks changes during editing.
When saving:
- new rows are inserted
- modified rows are updated
- deleted rows are removed
Only the changes are transmitted.
This significantly improves performance for larger applications.
Save and Cancel Workflow
Lixcel follows a desktop-style editing model.
Users can freely edit data while working.
Only when Save is pressed are changes committed.
This provides several advantages:
- fewer server requests
- safer editing
- better user experience
- easier conflict management
Built-In Relationships
Applications often contain multiple related lists.
For example:
- Customers
- Orders
- Products
- Invoices
Lixcel treats these like relational database tables, allowing applications to model complex business scenarios while remaining easy to configure.
Extensible Business Logic
Simple users can use predefined computed functions.
Examples include:
- totals
- averages
- percentages
- date calculations
Advanced users can extend applications using JavaScript for custom business rules.
This combination provides a low learning curve while allowing virtually unlimited customization.
AI Integration
AI is integrated directly into the platform.
Depending on the scenario, Lixcel can use:
- cloud-hosted language models
- locally executed AI models
- contextual application data
This enables users to generate content, analyze information, and interact with their applications using natural language.
Progressive Web App
Lixcel itself is a Progressive Web App.
That means it can:
- run on desktop
- run on tablets
- run on phones
- work offline
- install like a native application
Users don’t need to install different versions for different operating systems.
Designed for Growth
Whether someone is building a simple shopping list or a complete business management solution, the same architecture powers every application.
As requirements grow, users can move from local storage to cloud synchronization, connect external services, add AI capabilities, and customize business logic-all without rebuilding their applications from scratch.
Looking Ahead
The architecture behind Lixcel continues to evolve.
Future enhancements include smarter AI-assisted application creation, automatic field type suggestions, additional integrations, and expanded automation capabilities.
Our goal remains the same:
Enable anyone to build powerful data-driven applications through configuration instead of coding.