What is web applications and what does it involve?

TechSteps builds custom web applications for workflows that off-the-shelf software does not fit. That means modelling how the work actually happens, designing a data model that will survive requirement changes, and shipping to an environment with real deployment, backup and observability. The application is treated as something that has to be operated for years, not just delivered.

What this solves

The problem underneath the request.

Businesses reach a point where the workflow lives in a spreadsheet, three tools that do not talk to each other, and one person who knows how it all connects. Every off-the-shelf product handles eighty percent of the process and fights the rest.

The temptation is to force the business to match the software. Sometimes that is right. Often the process is the thing that makes the business work, and bending it to fit a generic tool destroys the advantage.

Custom software is the correct answer less often than software vendors suggest and more often than businesses assume. The deciding factor is usually whether the workflow is genuinely specific or merely undocumented.

Who this is for

  • Operations teams whose core process does not fit any product they have tried
  • Businesses running critical workflows in spreadsheets that have outgrown them
  • Companies needing several systems to exchange data reliably
  • Founders building the first version of a software product
  • Teams who inherited an application nobody understands and need it stabilized or replaced

When people call us

Situations that usually start this conversation.

If more than one of these sounds familiar, the underlying cause is often a single issue rather than several separate ones.

  • 01 A spreadsheet has become a system of record and people are afraid to change it
  • 02 The same data is being re-entered into two or three different tools
  • 03 A process depends on one person because only they know the exceptions
  • 04 An existing application cannot be changed safely because nothing is tested
  • 05 Reporting requires manual assembly every month
  • 06 A vendor is retiring a product you depend on

Technical scope

What the work actually covers.

Not every engagement includes all of this. The scope is agreed in writing before we start, and anything excluded is named rather than left ambiguous.

Domain and data

  • Workflow modelling with the people who actually do the work
  • Data model designed for the changes you can already anticipate
  • Migration from spreadsheets or a legacy system
  • Validation rules and the handling of legitimate exceptions
  • Audit trail where the business needs to know who changed what

Application

  • Server-rendered or client application, chosen for the actual usage pattern
  • Authentication, roles and permission boundaries
  • Background jobs, queues and scheduled work
  • File handling, exports and reporting
  • Integrations with the systems you already run

Operations

  • Deployment pipeline with a rollback path
  • Environment separation and configuration management
  • Database backup with a verified restore
  • Logging, error tracking and alerting
  • Performance under the load you actually expect

Maintainability

  • Automated tests covering the logic that would be expensive to get wrong
  • Dependency management and update strategy
  • Documentation aimed at the next engineer, not at us
  • Local development setup that a new developer can run

How we approach it

The order matters more than the checklist.

  1. 01

    Map the real workflow

    Including the exceptions. The exceptions are where off-the-shelf software failed and where a naive build will fail too. We talk to the people doing the work, not only to whoever commissioned the project.

  2. 02

    Decide whether to build at all

    If an existing product would do the job with a small process change, we will say so. It is a shorter engagement for us and a much cheaper outcome for you.

  3. 03

    Design the data model

    Most expensive rewrites trace back to a data model that could not express something the business later needed. This is where the time is worth spending.

  4. 04

    Build the smallest useful version

    Something real people use for real work as early as possible. Feedback from actual use is worth more than a longer specification.

  5. 05

    Set up operations before you depend on it

    Backups, monitoring, error tracking and deployment in place before the application becomes load-bearing, not after the first incident.

  6. 06

    Iterate and hand over

    Expand based on use, then document what a future engineer needs. You own the code throughout.

What goes wrong

How this work fails when it is done badly.

These are the patterns we see most often when we are called in to fix someone else's work, or our own from earlier in our careers.

  • The data model is designed around the first screen

    It works until the business needs a report that crosses two concepts the model treats as unrelated. Then it is a migration, not a feature.

  • Nobody modelled the exceptions

    The happy path is automated, the exceptions still happen, and staff quietly return to the spreadsheet. Now there are two systems of record.

  • No tests around the expensive logic

    Not everything needs a test. Billing, permissions and anything that touches money or access do. Without them nobody will dare change the code.

  • Operations arrives after launch

    The first time anyone thinks about backups is when they are needed. A backup that has never been restored is a hypothesis, not a safety net.

  • It becomes unmaintainable by anyone else

    If only the original developer can change it, you have replaced a dependency on a spreadsheet with a dependency on a person.

What each side brings

What we need from you

  • Access to the people who actually perform the workflow
  • A decision maker who can resolve conflicting requirements
  • Existing data, and someone who can explain its quirks
  • Credentials or documentation for systems we need to integrate with
  • Realistic availability for feedback on working software

What you get

  • A working application in production, with source code you own
  • Documented data model and architecture decisions
  • Deployment pipeline with rollback
  • Backup arrangement with a restore that has been tested
  • Monitoring, error tracking and alerting
  • Automated tests over the critical logic
  • Handover documentation written for the next engineer

Where we stop

  • We will tell you when an existing product would solve the problem more cheaply, even though that ends the engagement.
  • We do not take on projects where the requirements cannot be discussed with the people who do the work.
  • Fixed-price delivery needs a well-understood problem. For genuinely exploratory work we would rather structure it as iterative delivery than quote a number that will not survive contact with reality.

Questions we actually get asked

Straight answers.

How do we know custom software is the right answer?

Ask whether the workflow is genuinely specific to how you compete, or just undocumented. If three competitors run the same process on a standard product, you probably can too. If the process is the reason customers choose you, forcing it into a generic tool has a real cost. We are happy to help make that call before any build is proposed.

Who owns the code?

You do, from the start, in your repository. We do not build businesses on the assumption that clients cannot leave.

What technology will you use?

Something appropriate and boring. The main criteria are that the problem fits the tool, and that you could hire someone else to maintain it. We are not going to pick an unusual stack because it is interesting to us.

What happens if we want to bring it in house later?

That is a normal outcome and we plan for it. Documentation is written for a future engineer, the local development setup is runnable by someone new, and the architecture decisions are recorded with their reasoning.

Can you take over an application someone else built?

Often, yes. We would usually start with a short assessment covering what it does, how it is deployed, what tests exist and what the immediate risks are. Sometimes the honest recommendation is to stabilize rather than extend it.

Discuss an Application.

Describe the system and what is going wrong with it. A short technical conversation is usually enough for us to tell you whether this is the right work and roughly what it involves.