A tool built around your process, not another spreadsheet
We build lightweight applications for registers, approval workflows and operational work where an off-the-shelf system is too heavy and a spreadsheet is no longer safe. They run in a browser and on a phone.
When a spreadsheet is no longer enough
Low-code makes sense for a process that can be described but doesn't fit off-the-shelf software.
If you recognise two or three of these signs, a free online consultation will show whether to start, and where.
- The file has several copies and no one knows which one is current.
- Case status exists only in messages and in someone's memory.
- There's no change history, so you can't tell who changed what.
- Someone retypes paper or PDF forms into a spreadsheet.
- Off-the-shelf systems have too many features or don't fit your process.
- Field staff send photos and data by email because they have no proper tool.
What we do, from workshop to go-live.
- 1
Workshop with users
Roles, data, stages, exceptions and decisions, written down with the people who will use the application.
- 2
Screen mockups
Draft views and forms for approval before we build anything.
- 3
Data model and permissions
Data structure, roles and access rules. This is the part that decides whether the application survives future growth.
- 4
Build and validation
The application built on a platform suited to your needs, such as AppSheet or Power Apps, with field validation so incorrect data doesn't get into the system.
- 5
Integrations
Connections to email, files, the ERP system or other sources where the process requires it.
- 6
Testing and data migration
Acceptance testing with users and migration of historical data from spreadsheets.
- 7
Training and support
User training and 60 days of support after go-live, because that's when the questions nobody asked during testing come up.
What you get in writing.
The application, together with the knowledge needed to maintain it.
Process map
Roles, case statuses and the rules for moving between them.
Working application
Views, forms, validation and permissions, on accounts owned by the business.
Acceptance scenarios
A list of tests agreed before release, and their results.
Documentation
Configuration, integrations, how to export data and an administrator guide.
Who is responsible for what.
The application and data stay on the company's accounts. We don't build anything that can't be handed over to someone else.
On the NexaIT side
- workshop, mockups and data model design
- building the application, validation and permissions
- integrations within the agreed scope
- acceptance testing, data migration and training
- support for 60 days after launch
On your side
- naming the person who decides on the process
- users taking part in the workshop and prototype testing
- low-code platform licences, paid directly to the vendor
- the data to migrate, and deciding which of it is still current
- approving mock-ups before the build
What this service doesn't include.
Clear scope boundaries are part of a good contract. We talk about them before you sign, not when the first invoice arrives.
If an off-the-shelf product solves the problem more cheaply and simply, we'll recommend it.
- building a system without a person responsible for the process
- copying a flawed process one-to-one into an application
- critical solutions without a data export plan
- low-code platform licences, a recurring cost paid to the vendor
- very high-traffic systems with real-time processing that need custom-built software
When low-code fits and when it doesn't
It makes sense if
- The process is company-specific, but it can be described.
- Users can test the prototype regularly and tell you what doesn't work.
- Quick go-live and developing the application in stages matter to you.
We don't recommend it if
- The system needs to handle very high traffic or unusual real-time calculations.
- There's an off-the-shelf product that does exactly what you need.
- Nobody decides what the process should look like.
What affects the price
Cost grows with logic and integrations, not with the number of screens. A simple application with one to three views starts at PLN 6,500 net.
- number of roles and access rules
- number of steps and exceptions in the process
- integrations with other systems
- the volume and state of data to migrate from spreadsheets
- whether the application also needs to work in the field, on a phone
Questions before you decide.
Can the data be exported later?
Yes, and we settle this before choosing the platform, not afterwards. How to export data is part of the documentation.
Can the application be developed in stages?
Yes. This is one of the main reasons for choosing low-code, provided that we keep data and permissions in order from the beginning.
Which platform do you build on?
We match it to what you already use. A business on Google Workspace will usually get an AppSheet application, one on Microsoft 365 a Power Apps application. The point is not to add yet another ecosystem.
What about licences?
Platform licences are a recurring cost that depends on the number of users. We show them separately in the quote, and you buy them directly from the vendor.
Related
Free · 60 minutes online · no obligation
First, a conversation about the process, then the tool.
- You tell us about the processOnline, by video call. What takes up time today, which systems hold the data and what you want to achieve.
- We tell you whether it's worth itSometimes a change to a spreadsheet or a process is enough. If so, we'll say that instead of proposing a project.
- You get the next stepBy email after the meeting: what to map, what data to prepare and what the price depends on.
We don't use a contact form. We answer the phone and reply to emails.