Writing

10 min read

Angular Signal Forms: A Modern Approach to Form Management

A look at Angular's experimental Signal Forms: signal-based, type-safe form handling with built-in validation and two-way binding.

Angular / Forms / Signals / TypeScript / Web Development

Forms are the backbone of user interaction in web applications. Whether it's a simple login form or a complex multi-step wizard, managing form state, validation, and user feedback has always been a challenge. With Angular v21, the framework introduces Signal Forms - an experimental yet promising approach to form management that builds on the reactive foundation of signals.

⚠️ Important Note

Before we dive in, it's crucial to understand that Signal Forms are experimental. The API may change in future releases, and it's not recommended for production applications unless you understand the risks. However, for new applications built with signals, Signal Forms offer a glimpse into the future of Angular form management.

What Are Signal Forms?

Signal Forms address the traditional challenges of form management by:

  • Synchronizing state automatically - Automatically sync the form data model with bound form fields
  • Providing type safety - Support fully type-safe schemas & bindings between UI controls and data model
  • Centralizing validation logic - Define all validation rules in one place using a validation schema

Unlike Template-driven Forms or Reactive Forms, Signal Forms are model-driven. The form's structure and state are derived directly from a signal-based model, making the entire system more reactive and easier to reason about.

Prerequisites

To use Signal Forms, you need:

  • Angular v21 or higher
  • Understanding of Angular Signals

Getting Started with Signal Forms

Setup

Signal Forms are already included in the @angular/forms package. You just need to import the necessary functions and directives:

import { form, Field, required, email } from '@angular/forms/signals';

The Field directive must be imported into any component that binds form fields to HTML inputs.

Building a User Registration Form

Let's build a practical example: a user registration form that collects name, email, and an array of skills.

💻 Complete Working Example on GitHub - Clone and run the full application with all the code from this tutorial!

Step 1: Define the Form Model

Form models are the foundation of Signal Forms. They serve as the single source of truth for your form data.

import { JsonPipe } from '@angular/common';
import { Component, signal } from '@angular/core';
import { applyEach, email, Field, form, minLength, required } from '@angular/forms/signals';

interface Skill {
  name: string;
  proficiency: string;
}

interface UserRegistrationData {
  name: string;
  email: string;
  skills: Skill[];
}

@Component({
  selector: 'app-root',
  imports: [Field, JsonPipe],
  templateUrl: './app.html',
  styleUrl: './app.css',
})
export class App {
  // Create the form model with initial values
  registrationModel = signal<UserRegistrationData>({
    name: '',
    email: '',
    skills: [{ name: '', proficiency: 'beginner' }],
  });

  // Create the form with validation schema
  registrationForm = form(this.registrationModel, (schemaPath) => {
    // Validate name
    required(schemaPath.name, {
      message: 'Name is required',
    });
    minLength(schemaPath.name, 2, {
      message: 'Name must be at least 2 characters',
    });

    // Validate email
    required(schemaPath.email, {
      message: 'Email is required',
    });
    email(schemaPath.email, {
      message: 'Please enter a valid email address',
    });

    // Validate each skill in the array
    applyEach(schemaPath.skills, (skill) => {
      required(skill.name, {
        message: 'Skill name is required',
      });
      required(skill.proficiency, {
        message: 'Proficiency level is required',
      });
    });
  });

  // Add a new skill
  addSkill() {
    this.registrationForm.skills().value.update((skills) => [
      ...skills,
      { name: '', proficiency: 'beginner' },
    ]);
  }

  // Remove a skill
  removeSkill(index: number) {
    this.registrationForm.skills().value.update((skills) => skills.filter((_, i) => i !== index));
  }

  // Handle form submission
  async onSubmit(event: Event) {
    event.preventDefault();
    if (this.registrationForm().valid()) {
      const formData = this.registrationForm().value();
      console.log('Form submitted:', formData);

      // Here you would typically send data to your backend
      // await this.userService.register(formData);

      alert('Registration successful!');
    } else {
      alert('Please fix all errors before submitting');
    }
  }
}

Step 2: Create the Template

Now let's create a user-friendly template that displays the form:

<div class="registration-container">
  <h2>User Registration</h2>

  <form (submit)="onSubmit($event)">
    <!-- Name Field -->
    <div class="form-group">
      <label for="name">Full Name *</label>
      <input
        id="name"
        type="text"
        [field]="registrationForm.name"
        placeholder="Enter your full name"
      />

      @if (registrationForm.name().touched() && registrationForm.name().invalid()) {
      <div class="error-messages">
        @for (error of registrationForm.name().errors(); track error.kind) {
        <span class="error">{{ error.message }}</span>
        }
      </div>
      }
    </div>

    <!-- Email Field -->
    <div class="form-group">
      <label for="email">Email Address *</label>
      <input
        id="email"
        type="email"
        [field]="registrationForm.email"
        placeholder="your.email@example.com"
      />

      @if (registrationForm.email().touched() && registrationForm.email().invalid()) {
      <div class="error-messages">
        @for (error of registrationForm.email().errors(); track error.kind) {
        <span class="error">{{ error.message }}</span>
        }
      </div>
      }
    </div>

    <!-- Skills Array -->
    <div class="form-section">
      <h3>Skills</h3>

      @for (skill of registrationModel().skills; track $index) {
      <div class="skill-item">
        <div class="skill-fields">
          <div class="form-group flex-grow">
            <label [attr.for]="'skill-name-' + $index">Skill Name *</label>
            <input
              [id]="'skill-name-' + $index"
              type="text"
              [field]="registrationForm.skills[$index].name"
              placeholder="e.g., Angular, TypeScript"
            />

            @if (registrationForm.skills[$index].name().touched() &&
            registrationForm.skills[$index].name().invalid()) {
            <div class="error-messages">
              @for (error of registrationForm.skills[$index].name().errors(); track error.kind) {
              <span class="error">{{ error.message }}</span>
              }
            </div>
            }
          </div>

          <div class="form-group">
            <label [attr.for]="'skill-proficiency-' + $index">Proficiency *</label>
            <select
              [id]="'skill-proficiency-' + $index"
              [field]="registrationForm.skills[$index].proficiency"
            >
              <option value="beginner">Beginner</option>
              <option value="intermediate">Intermediate</option>
              <option value="advanced">Advanced</option>
              <option value="expert">Expert</option>
            </select>
          </div>
        </div>

        @if ($index > 0) {
        <button type="button" class="btn-remove" (click)="removeSkill($index)">Remove</button>
        }
      </div>
      }

      <button type="button" class="btn-secondary" (click)="addSkill()">+ Add Another Skill</button>
    </div>

    <!-- Display Form Summary -->
    <div class="form-summary">
      <h4>Form Status</h4>
      <ul>
        <li>Valid: {{ registrationForm().valid() ? '✅' : '❌' }}</li>
        <li>Touched: {{ registrationForm().touched() ? 'Yes' : 'No' }}</li>
        <li>Dirty: {{ registrationForm().dirty() ? 'Yes' : 'No' }}</li>
      </ul>
    </div>

    <!-- Submit Button -->
    <div class="form-actions">
      <button type="submit" class="btn-primary" [disabled]="!registrationForm().valid()">
        Register
      </button>
    </div>
  </form>

  <!-- Preview of Current Data -->
  <div class="data-preview">
    <h4>Current Form Data</h4>
    <pre>{{ registrationModel() | json }}</pre>
  </div>
</div>

Step 3: Add Styling

Let's add some CSS to make our form look professional:

.registration-container {
  max-width: 800px;
  margin: 2rem auto;
  padding: 2rem;
  background: #ffffff;
  border-radius: 8px;
  box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
}

h2 {
  color: #333;
  margin-bottom: 1.5rem;
}

h3 {
  color: #555;
  margin-top: 2rem;
  margin-bottom: 1rem;
}

.form-group {
  margin-bottom: 1.5rem;
}

.form-group label {
  display: block;
  margin-bottom: 0.5rem;
  font-weight: 500;
  color: #555;
}

.form-group input,
.form-group select {
  width: 100%;
  padding: 0.75rem;
  border: 1px solid #ddd;
  border-radius: 4px;
  font-size: 1rem;
  transition: border-color 0.3s;
}

.form-group input:focus,
.form-group select:focus {
  outline: none;
  border-color: #007bff;
}

.form-section {
  margin-top: 2rem;
  padding: 1.5rem;
  background: #f8f9fa;
  border-radius: 6px;
}

.skill-item {
  margin-bottom: 1rem;
  padding: 1rem;
  background: white;
  border-radius: 4px;
  border: 1px solid #e0e0e0;
}

.skill-fields {
  display: flex;
  gap: 1rem;
  margin-bottom: 0.5rem;
}

.flex-grow {
  flex: 1;
}

.error-messages {
  margin-top: 0.25rem;
}

.error {
  display: block;
  color: #dc3545;
  font-size: 0.875rem;
  margin-top: 0.25rem;
}

.btn-primary,
.btn-secondary,
.btn-remove {
  padding: 0.75rem 1.5rem;
  border: none;
  border-radius: 4px;
  font-size: 1rem;
  cursor: pointer;
  transition: background-color 0.3s;
}

.btn-primary {
  background-color: #007bff;
  color: white;
}

.btn-primary:hover:not(:disabled) {
  background-color: #0056b3;
}

.btn-primary:disabled {
  background-color: #ccc;
  cursor: not-allowed;
}

.btn-secondary {
  background-color: #6c757d;
  color: white;
  margin-top: 1rem;
}

.btn-secondary:hover {
  background-color: #545b62;
}

.btn-remove {
  background-color: #dc3545;
  color: white;
  padding: 0.5rem 1rem;
}

.btn-remove:hover {
  background-color: #c82333;
}

.form-actions {
  margin-top: 2rem;
}

.form-summary {
  margin-top: 2rem;
  padding: 1rem;
  background: #e7f3ff;
  border-radius: 4px;
}

.form-summary ul {
  list-style: none;
  padding: 0;
  margin: 0.5rem 0 0 0;
}

.form-summary li {
  padding: 0.25rem 0;
}

.data-preview {
  margin-top: 2rem;
  padding: 1rem;
  background: #f8f9fa;
  border-radius: 4px;
  overflow-x: auto;
}

.data-preview pre {
  margin: 0.5rem 0 0 0;
  font-size: 0.875rem;
}

Key Concepts Explained

1. Form Models vs Domain Models

Signal Forms distinguish between form models (representing raw user input in the UI) and domain models (representing business logic). This separation allows you to:

  • Tailor the form structure to the user experience
  • Transform data between representations as needed
  • Keep form logic separate from business logic

2. Two-Way Data Binding

The [field] directive creates automatic two-way synchronization:

User input → Model:

  1. User types in an input element
  2. The [field] directive detects the change
  3. Field state updates
  4. Model signal updates

Programmatic update → UI:

  1. Code updates the model with set() or update()
  2. Model signal notifies subscribers
  3. Field state updates
  4. The [field] directive updates the input element

3. Validation Schema

Validation rules are defined in a schema function passed to form(). Key benefits:

  • Centralized - All validation logic in one place
  • Reactive - Automatically runs when values change
  • Type-safe - Full TypeScript support
  • Composable - Mix built-in and custom validators

4. Working with Arrays

Signal Forms handle arrays elegantly with:

  • Dynamic length - Add/remove items as needed
  • Automatic tracking - Items maintain state even when reordered
  • Array validation - Use applyEach() to validate each item

Advanced Features

Cross-Field Validation

Validate fields that depend on each other:

form(model, (schemaPath) => {
  validate(schemaPath.confirmEmail, ({ value, valueOf }) => {
    if (value() !== valueOf(schemaPath.email)) {
      return { 
        kind: 'emailMismatch', 
        message: 'Emails do not match' 
      };
    }
    return null;
  });
});

Async Validation

Check values against a server:

import { validateHttp } from '@angular/forms/signals';

form(model, (schemaPath) => {
  validateHttp(schemaPath.username, {
    request: ({ value }) => `/api/check-username?username=${value()}`,
    onSuccess: (response) => {
      if (response.taken) {
        return { 
          kind: 'usernameTaken', 
          message: 'Username is already taken' 
        };
      }
      return null;
    },
    onError: () => ({ 
      kind: 'networkError', 
      message: 'Could not verify username' 
    })
  });
});

Custom Validators

Create reusable validation rules:

function strongPassword(field: any, options?: { message?: string }) {
  validate(field, ({ value }) => {
    const password = value();
    const hasUpper = /[A-Z]/.test(password);
    const hasLower = /[a-z]/.test(password);
    const hasNumber = /[0-9]/.test(password);
    const hasSpecial = /[!@#$%^&*]/.test(password);
    
    if (!hasUpper || !hasLower || !hasNumber || !hasSpecial) {
      return {
        kind: 'strongPassword',
        message: options?.message || 
          'Password must contain uppercase, lowercase, number, and special character'
      };
    }
    return null;
  });
}

Best Practices

1. Initialize All Fields

Always provide initial values for every field:

// ✅ Good
const model = signal({
  name: '',
  email: '',
  age: 0
});

// ❌ Avoid
const model = signal({
  name: ''
  // Missing email and age - won't be in field tree
});

2. Use Specific Types

Define interfaces for better type safety:

interface UserFormData {
  name: string;
  email: string;
  age: number;
}

const model = signal<UserFormData>({
  name: '',
  email: '',
  age: 0
});

3. Avoid Undefined

Use appropriate empty values instead of undefined:

// ✅ Good
interface FormData {
  name: string;
  birthday: Date | null;
}

// ❌ Avoid
interface FormData {
  name?: string;  // Implicitly allows undefined
  birthday?: Date;
}

4. Show Validation at the Right Time

Use touched() to prevent premature error display:

@if (field().touched() && field().invalid()) {
  <div class="errors">
    @for (error of field().errors(); track error.kind) {
      <span>{{ error.message }}</span>
    }
  </div>
}

Comparison with Other Form Systems

FeatureSignal FormsReactive FormsTemplate-driven
Type Safety✅ Full✅ Full (with TypeScript)❌ Limited
Two-way Binding✅ Automatic⚠️ Manual✅ Automatic
Validation Schema✅ Centralized⚠️ Distributed⚠️ Distributed
Reactive Updates✅ Built-in✅ RxJS-based⚠️ Limited
Learning CurveMediumMediumLow
Maturity⚠️ Experimental✅ Stable✅ Stable

When to Use Signal Forms

✅ Use Signal Forms when:

  • Building a new application with Angular v21+
  • Already using signals throughout your app
  • Want automatic synchronization and type safety
  • Need centralized validation logic
  • Comfortable with experimental features

❌ Avoid Signal Forms when:

  • Working on production applications requiring stability
  • Using Angular versions below v21
  • Team is not comfortable with experimental APIs
  • Need features from mature form libraries

Conclusion

Angular Signal Forms represent a modern, reactive approach to form management that aligns perfectly with Angular's signals architecture. While still experimental, they offer powerful features like automatic synchronization, type safety, and centralized validation that make form development more intuitive and maintainable.

The example we built demonstrates how Signal Forms handle common scenarios: simple fields, complex validation, and dynamic arrays. As the API matures and stabilizes, Signal Forms have the potential to become the preferred way to build forms in Angular.

Resources


Have you tried Signal Forms in your Angular projects? Share your experiences in the comments below!

Comments

© 2026 Devendra Milmile

Set in Newsreader, Inter and IBM Plex Mono. Built with React and Tailwind CSS.

Back to top