Product and Application Design
Flows, screens and states for a web application, including the unglamorous parts: permissions, bulk actions, edge cases and what an empty account looks like on day one.
We design internal tools around the decisions and tasks teams perform daily.
NovaCraft maps roles, data, actions and integrations before designing, building and testing web applications that support real operational workflows.
Before a single chart is drawn, four things need answering:
Who opens this, and how often?
What decision are they making when they do?
What would make them act, and what is merely interesting?
What happens when the data is missing, stale or wrong?
A screen that answers those is short. A screen that does not tends to grow: another metric, another filter, another tab, until nobody can find the one number they came for.
We design for the decision first and the completeness second. Everything else stays available, but it stops competing for attention with the thing that matters.
These projects vary more than websites do. Scope, integrations and data volume change the work substantially, so we define all three before estimating.
Flows, screens and states for a web application, including the unglamorous parts: permissions, bulk actions, edge cases and what an empty account looks like on day one.
Interfaces that turn tables into something readable, with the right chart for each question and defaults that suit how the data is actually reviewed.
The internal side of a product: managing records, users, content and settings without needing a developer for routine changes.
Access designed deliberately, who sees what, who can change it, and what is recorded when they do.
Connecting the systems you already run, CRMs, payment providers, spreadsheets, internal databases, with sensible handling of failures and rate limits.
Replacing manual steps that are repeated daily, where the win is hours returned rather than a new feature.
Scheduled reports, filtered exports and shareable views, so people can get data out in the format the rest of their job needs.
For applications that were fine at a thousand records and are struggling at a million, finding where the time actually goes.
Application choices are harder to reverse than website choices, so we make them against your data, your team and your expected growth rather than habit.
Used for interfaces with real state to manage. TypeScript is not optional here, the compiler catches a class of bug that testing alone tends.
Used for charts, large sortable tables and virtualised lists that stay responsive with tens of thousands of rows.
Used for application logic, schema design, queries and the interfaces other systems talk to.
Used for sign-in, sessions, role checks and deployment, with environments separated so nothing is tested in production.
Used for end-to-end tests on critical flows, unit tests on logic, and error reporting once real people are using it.
Application demos show the happy path. What decides whether a tool survives its first month is everything around that path: what happens on a slow connection, on a stale session, or when two people edit the same record.
We treat those as requirements rather than as bugs to be found later, and we tell you which ones we have covered.
Depending on scope, our application builds can include:
Not every project needs all of these. We will tell you which ones your project does need, and which are worth deferring until you have users.
Where the shared sheet has become the system of record, and version conflicts are now a weekly cost.
Customer-facing applications that need a considered interface, clear onboarding and billing that works.
Businesses coordinating jobs, stock, people or deliveries where timing and status visibility drive the day.
Giving your customers a place to see their own data, documents and progress without emailing to ask.
Where numbers exist in five systems and someone spends a day each month assembling them by hand.
Applications that worked at launch and now take seconds per screen as the data has grown.
Scope drives the list. A typical application project may include:
The delivery method stays visible to both teams. Scope, responsibilities, feedback, approvals and handover are documented from the start.
We document deliverables, responsibilities, dependencies, review points and exclusions before production begins, so every participant works from the same agreed scope.
Files, notes, decisions, links and current priorities stay in one shared workspace, giving both teams a consistent source of project information.
Each week we record completed work, current tasks, blockers, decisions required and the next review point, keeping progress visible without constant meetings.
Feedback is consolidated by the client decision owner, reviewed against the agreed objective, then recorded before the next production stage begins.
Requests outside the approved scope are documented with their impact on timing, effort and dependencies before either team commits to the change.
Before handover, we review agreed acceptance criteria, test required journeys, document remaining actions and confirm ownership for launch or ongoing support.
Working instructions
A website mainly presents information. A web application does work, it holds accounts, stores and changes data, enforces permissions and produces results based on what a user does. Applications need a data model, a back end and testing, which is why they are scoped and priced differently.
Often, yes. We can add to an existing codebase, build a new interface over an existing database, or integrate with systems through their APIs. We start with a review, because sometimes extending is cheaper and sometimes replacing is.
A focused internal tool or dashboard can take four to eight weeks. A full product with accounts, billing and multiple roles usually runs three months or more. The number of integrations tends to affect the timeline more than the number of screens.
You do. Work is committed to a repository you own, deployed to accounts in your name. There is no dependency on us to keep the application running.
That is the intention. We use mainstream technologies rather than anything exotic, document setup and architecture, and can run a handover with your developers. We are also happy to maintain it ourselves if you would rather.
Permission checks are enforced on the server, not just hidden in the interface. Secrets stay in environment configuration and never in the front end. Environments are separated, dependencies are kept current, and access is limited to what each role needs. For regulated data we will tell you plainly what is and is not within our scope.
That depends on decisions made early, which is why we ask about expected volume during scoping. Pagination, indexing, query design and virtualised tables are planned in rather than added after a slowdown.
Yes, and it is common. We begin with an assessment of the existing code, dependencies and data, then give you an honest view of what can be built on and what needs replacing before we quote the work.
The best custom tools usually replace something tedious that happens every week. Those are the projects worth building, and they are easy to scope once we understand the current process.
Describe how it works today, where it breaks, and what you wish it did instead.
Clear scope. Your code, your accounts. An honest view of what it will take.