---
title: Web systems
url: https://nandomoreira.dev/en/services/web-systems
---

# A web system with sign-in and data, built to last.

I start by planning what the first version needs. Then I build it in parts, with tests, and hand over the code and accounts in your name.

## A prototype is not a system

What impresses in a demo has to hold up day to day, with many people and real data.

### Demo or spreadsheet

- One person uses it at a time
- Everyone sees everything
- Data scattered across spreadsheets and files
- Changes made straight in production
- Nobody knows what broke or when

### A system built to last

- Many people at once, each with their own access
- Role-based permissions, checked on the server
- A database with rules and backups
- A test environment before every release
- Error logs and a history of what changed

## What usually stalls a system that grew without a design

This is what I settle in the design, before writing the first screen.

- **Access and permissions** (Critical): Each person must see only what they are allowed to, and the server has to enforce it.
- **Data model** (Critical): Improvised tables that duplicate information and stall reports.
- **Login and accounts** (High): Sign-up, password recovery and invitations that must always work.
- **Integrations** (High): Payments, email and other tools that must talk without losing data.
- **Tests** (Medium): Without tests, every new screen risks breaking the ones that already work.
- **Documentation** (Medium): Whoever comes next must understand the system without depending on me.

## How the system is put together

Four layers, each with one job. These are the tools I use; the final choice depends on the project.

- **Interface:** The screens your team and your customers use, fast on phones and desktops. (Next.js, Astro, React, Tailwind CSS)
- **API and business rules:** Where the rules live: who can change what, and how. (Hono, Node.js, TypeScript, FastAPI)
- **Data and permissions:** The database, with access rules and backups. (PostgreSQL, Supabase, Firebase)
- **Deploys and operations:** Test environment, automated deploys and error logs. (Google Cloud, Docker, GitHub Actions)

## From design to a live system

Three phases. You approve the design before any line of code.

1. **Design:** We define the work before development.
   - Screens and rules
   - Data and permissions
2. **Development:** I build and verify the work in parts.
   - Test environment
   - Automated tests
3. **Follow-up:** You get instructions for operating the system.
   - Documented code
   - Operating instructions

## How it starts

You know what will be built, and in which parts, before you approve the build.

1. **First conversation:** Tell me what the system should handle.
   - 30 minutes, at no cost.
2. **Design and scope:** We define the first version.
   - Screens and rules
   - Data and permissions
3. **Build in parts:** You follow progress in a test environment.
   - Test environment
   - Automated tests
4. **Launch and handover:** I hand over the code, accounts and instructions.
   - Documented code
   - Operating instructions

## What you get

- Signed-in area
- Admin panel
- Automated tests from the start
- Documented code
- Test environment
- Agreed launch plan
- Operating instructions
- Code and accounts in your name

## See the potential before you invest

The design helps you understand what you will build before you invest in development.

- **Free first conversation:** Tell me what you need to solve.
- **Scope before code:** The first version has a defined scope.
- **You own the code:** The handover includes the system accounts.

## What the project excludes

- **Native app:** Apps for mobile app stores are outside the scope.
- **Content production:** You supply the product text and images.
- **Daily operation:** Your team operates the system after handover.

## Who handles the work

I lead the conversation and build the system. I use tests and code review to verify each delivery.

Agents in my workflow: Claude Code, Codex, Grok, Agy, Cursor.

## If one of these sounds familiar, it is time to design the system

- “The spreadsheet became the company system and nobody can get a formula wrong.”
- “The prototype won the client over, now it has to hold up under real use.”
- “Each person should see only their own data.”
- “Nobody wants to touch the code because nobody knows what will break.”
- “I want the code and the accounts in my name, not locked to a vendor.”

## Frequently asked questions

### How much should I define upfront?

Bring the problem. The design phase defines the first version.

### Will I own the code?

Yes. The code and accounts are in your name.

### Which details get set during design?

We define the first release, its screens, business rules and data.

### Can we start small?

Yes. We can start with the workflow that most needs to move out of the spreadsheet.

