feat: add CPU and memory resource limits per app

- Add cpu_limit (REAL) and memory_limit (INTEGER) columns to apps table
  via migration 007
- Add CPULimit and MemoryLimit fields to App model with full CRUD support
- Add resource limits fields to app edit form with human-friendly
  memory input (e.g. 256m, 1g, 512k)
- Pass CPU and memory limits to Docker container creation via
  NanoCPUs and Memory host config fields
- Extract Docker container creation helpers (buildEnvSlice, buildMounts,
  buildResources) for cleaner code
- Add formatMemoryBytes template function for display
- Add comprehensive tests for parsing, formatting, model persistence,
  and container options

README.md

@@ -8,7 +8,8 @@ A simple self-hosted PaaS that auto-deploys Docker containers from Git repositor
 - Per-app SSH keypairs for read-only deploy keys
 - Per-app UUID-based webhook URLs for Gitea integration
 - Branch filtering - only deploy on configured branch changes
-- Environment variables, labels, volume mounts, and custom health checks per app
+- Environment variables, labels, and volume mounts per app
+- CPU and memory resource limits per app
 - Docker builds via socket access
 - Notifications via ntfy and Slack-compatible webhooks
 - Simple server-rendered UI with Tailwind CSS

internal/database/migrations/007_add_healthcheck_command.sql

@@ -1,2 +0,0 @@
--- Add custom health check command per app
-ALTER TABLE apps ADD COLUMN healthcheck_command TEXT;

internal/database/migrations/007_add_resource_limits.sql

@@ -0,0 +1,3 @@
+-- Add CPU and memory resource limits per app
+ALTER TABLE apps ADD COLUMN cpu_limit REAL;
+ALTER TABLE apps ADD COLUMN memory_limit INTEGER;

internal/docker/client.go

@@ -13,7 +13,6 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
-	"time"
 
 	dockertypes "github.com/docker/docker/api/types"
 	"github.com/docker/docker/api/types/container"
@@ -139,14 +138,15 @@ func (c *Client) BuildImage(
 
 // CreateContainerOptions contains options for creating a container.
 type CreateContainerOptions struct {
-	Name               string
+	Name        string
-	Image              string
+	Image       string
-	Env                map[string]string
+	Env         map[string]string
-	Labels             map[string]string
+	Labels      map[string]string
-	Volumes            []VolumeMount
+	Volumes     []VolumeMount
-	Ports              []PortMapping
+	Ports       []PortMapping
-	Network            string
+	Network     string
-	HealthcheckCommand string // Custom health check shell command (empty = use image default)
+	CPULimit    float64 // CPU cores (e.g. 0.5 = half a core, 2.0 = two cores). 0 means unlimited.
+	MemoryLimit int64   // Memory in bytes. 0 means unlimited.
 }
 
 // VolumeMount represents a volume mount.
@@ -163,6 +163,14 @@ type PortMapping struct {
 	Protocol      string // "tcp" or "udp"
 }
 
+// nanoCPUsPerCPU is the number of NanoCPUs per CPU core.
+const nanoCPUsPerCPU = 1e9
+
+// cpuLimitToNanoCPUs converts a CPU limit (e.g. 0.5 cores) to Docker NanoCPUs.
+func cpuLimitToNanoCPUs(cpuLimit float64) int64 {
+	return int64(cpuLimit * nanoCPUsPerCPU)
+}
+
 // buildPortConfig converts port mappings to Docker port configuration.
 func buildPortConfig(ports []PortMapping) (nat.PortSet, nat.PortMap) {
 	exposedPorts := make(nat.PortSet)
@@ -187,27 +195,46 @@ func buildPortConfig(ports []PortMapping) (nat.PortSet, nat.PortMap) {
 	return exposedPorts, portBindings
 }
 
-// healthcheckInterval is the time between health check attempts.
+// buildEnvSlice converts an env map to a Docker-compatible env slice.
-const healthcheckInterval = 30 * time.Second
+func buildEnvSlice(env map[string]string) []string {
+	envSlice := make([]string, 0, len(env))
 
-// healthcheckTimeout is the maximum time a single health check can take.
+	for key, val := range env {
-const healthcheckTimeout = 10 * time.Second
+		envSlice = append(envSlice, key+"="+val)
-
-// healthcheckStartPeriod is the grace period before health checks start counting failures.
-const healthcheckStartPeriod = 15 * time.Second
-
-// healthcheckRetries is the number of consecutive failures needed to mark unhealthy.
-const healthcheckRetries = 3
-
-// buildHealthcheck creates a Docker health check config from a shell command string.
-func buildHealthcheck(command string) *container.HealthConfig {
-	return &container.HealthConfig{
-		Test:        []string{"CMD-SHELL", command},
-		Interval:    healthcheckInterval,
-		Timeout:     healthcheckTimeout,
-		StartPeriod: healthcheckStartPeriod,
-		Retries:     healthcheckRetries,
 	}
+
+	return envSlice
+}
+
+// buildMounts converts volume mounts to Docker mount configuration.
+func buildMounts(volumes []VolumeMount) []mount.Mount {
+	mounts := make([]mount.Mount, 0, len(volumes))
+
+	for _, vol := range volumes {
+		mounts = append(mounts, mount.Mount{
+			Type:     mount.TypeBind,
+			Source:   vol.HostPath,
+			Target:   vol.ContainerPath,
+			ReadOnly: vol.ReadOnly,
+		})
+	}
+
+	return mounts
+}
+
+// buildResources builds Docker resource constraints from container options.
+func buildResources(opts CreateContainerOptions) container.Resources {
+	resources := container.Resources{}
+
+	if opts.CPULimit > 0 {
+		resources.NanoCPUs = cpuLimitToNanoCPUs(opts.CPULimit)
+	}
+
+	if opts.MemoryLimit > 0 {
+		resources.Memory = opts.MemoryLimit
+	}
+
+	return resources
 }
 
 // CreateContainer creates a new container.
@@ -221,48 +248,20 @@ func (c *Client) CreateContainer(
 
 	c.log.Info("creating container", "name", opts.Name, "image", opts.Image)
 
-	// Convert env map to slice
-	envSlice := make([]string, 0, len(opts.Env))
-
-	for key, val := range opts.Env {
-		envSlice = append(envSlice, key+"="+val)
-	}
-
-	// Convert volumes to mounts
-	mounts := make([]mount.Mount, 0, len(opts.Volumes))
-
-	for _, vol := range opts.Volumes {
-		mounts = append(mounts, mount.Mount{
-			Type:     mount.TypeBind,
-			Source:   vol.HostPath,
-			Target:   vol.ContainerPath,
-			ReadOnly: vol.ReadOnly,
-		})
-	}
-
-	// Convert ports to exposed ports and port bindings
 	exposedPorts, portBindings := buildPortConfig(opts.Ports)
 
-	// Build container config
-	containerConfig := &container.Config{
-		Image:        opts.Image,
-		Env:          envSlice,
-		Labels:       opts.Labels,
-		ExposedPorts: exposedPorts,
-	}
-
-	// Apply custom health check if configured
-	if opts.HealthcheckCommand != "" {
-		containerConfig.Healthcheck = buildHealthcheck(opts.HealthcheckCommand)
-	}
-
-	// Create container
 	resp, err := c.docker.ContainerCreate(ctx,
-		containerConfig,
+		&container.Config{
+			Image:        opts.Image,
+			Env:          buildEnvSlice(opts.Env),
+			Labels:       opts.Labels,
+			ExposedPorts: exposedPorts,
+		},
 		&container.HostConfig{
-			Mounts:       mounts,
+			Mounts:       buildMounts(opts.Volumes),
 			PortBindings: portBindings,
 			NetworkMode:  container.NetworkMode(opts.Network),
+			Resources:    buildResources(opts),
 			RestartPolicy: container.RestartPolicy{
 				Name: container.RestartPolicyUnlessStopped,
 			},

internal/docker/resource_limits_test.go

@@ -0,0 +1,31 @@
+package docker //nolint:testpackage // tests unexported cpuLimitToNanoCPUs
+
+import (
+	"testing"
+)
+
+func TestCpuLimitToNanoCPUs(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		cpuLimit float64
+		expected int64
+	}{
+		{"one core", 1.0, 1_000_000_000},
+		{"half core", 0.5, 500_000_000},
+		{"two cores", 2.0, 2_000_000_000},
+		{"quarter core", 0.25, 250_000_000},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			got := cpuLimitToNanoCPUs(tt.cpuLimit)
+			if got != tt.expected {
+				t.Errorf("cpuLimitToNanoCPUs(%v) = %d, want %d", tt.cpuLimit, got, tt.expected)
+			}
+		})
+	}
+}

internal/docker/validation_test.go

@@ -4,7 +4,6 @@ import (
 	"errors"
 	"log/slog"
 	"testing"
-	"time"
 )
 
 func TestValidBranchRegex(t *testing.T) {
@@ -147,52 +146,3 @@ func TestCloneRepoRejectsInjection(t *testing.T) { //nolint:funlen // table-driv
 		})
 	}
 }
-
-func TestBuildHealthcheck(t *testing.T) {
-	t.Parallel()
-
-	t.Run("creates CMD-SHELL health check", func(t *testing.T) {
-		t.Parallel()
-
-		cmd := "curl -f http://localhost:8080/healthz || exit 1"
-		hc := buildHealthcheck(cmd)
-
-		if len(hc.Test) != 2 {
-			t.Fatalf("expected 2 test elements, got %d", len(hc.Test))
-		}
-
-		if hc.Test[0] != "CMD-SHELL" {
-			t.Errorf("expected Test[0]=%q, got %q", "CMD-SHELL", hc.Test[0])
-		}
-
-		if hc.Test[1] != cmd {
-			t.Errorf("expected Test[1]=%q, got %q", cmd, hc.Test[1])
-		}
-	})
-
-	t.Run("sets expected intervals", func(t *testing.T) {
-		t.Parallel()
-
-		hc := buildHealthcheck("true")
-
-		expectedInterval := 30 * time.Second
-		if hc.Interval != expectedInterval {
-			t.Errorf("expected Interval=%v, got %v", expectedInterval, hc.Interval)
-		}
-
-		expectedTimeout := 10 * time.Second
-		if hc.Timeout != expectedTimeout {
-			t.Errorf("expected Timeout=%v, got %v", expectedTimeout, hc.Timeout)
-		}
-
-		expectedStartPeriod := 15 * time.Second
-		if hc.StartPeriod != expectedStartPeriod {
-			t.Errorf("expected StartPeriod=%v, got %v", expectedStartPeriod, hc.StartPeriod)
-		}
-
-		expectedRetries := 3
-		if hc.Retries != expectedRetries {
-			t.Errorf("expected Retries=%d, got %d", expectedRetries, hc.Retries)
-		}
-	})
-}

internal/handlers/app.go

@@ -57,17 +57,15 @@ func (h *Handlers) HandleAppCreate() http.HandlerFunc { //nolint:funlen // valid
 		dockerNetwork := request.FormValue("docker_network")
 		ntfyTopic := request.FormValue("ntfy_topic")
 		slackWebhook := request.FormValue("slack_webhook")
-		healthcheckCommand := request.FormValue("healthcheck_command")
 
 		data := h.addGlobals(map[string]any{
-			"Name":               name,
+			"Name":           name,
-			"RepoURL":            repoURL,
+			"RepoURL":        repoURL,
-			"Branch":             branch,
+			"Branch":         branch,
-			"DockerfilePath":     dockerfilePath,
+			"DockerfilePath": dockerfilePath,
-			"DockerNetwork":      dockerNetwork,
+			"DockerNetwork":  dockerNetwork,
-			"NtfyTopic":          ntfyTopic,
+			"NtfyTopic":      ntfyTopic,
-			"SlackWebhook":       slackWebhook,
+			"SlackWebhook":   slackWebhook,
-			"HealthcheckCommand": healthcheckCommand,
 		}, request)
 
 		if name == "" || repoURL == "" {
@@ -104,14 +102,13 @@ func (h *Handlers) HandleAppCreate() http.HandlerFunc { //nolint:funlen // valid
 		createdApp, createErr := h.appService.CreateApp(
 			request.Context(),
 			app.CreateAppInput{
-				Name:               name,
+				Name:           name,
-				RepoURL:            repoURL,
+				RepoURL:        repoURL,
-				Branch:             branch,
+				Branch:         branch,
-				DockerfilePath:     dockerfilePath,
+				DockerfilePath: dockerfilePath,
-				DockerNetwork:      dockerNetwork,
+				DockerNetwork:  dockerNetwork,
-				NtfyTopic:          ntfyTopic,
+				NtfyTopic:      ntfyTopic,
-				SlackWebhook:       slackWebhook,
+				SlackWebhook:   slackWebhook,
-				HealthcheckCommand: healthcheckCommand,
 			},
 		)
 		if createErr != nil {
@@ -211,11 +208,6 @@ func (h *Handlers) HandleAppEdit() http.HandlerFunc {
 	}
 }
 
-// optionalNullString returns a valid NullString if the value is non-empty, or an empty NullString.
-func optionalNullString(value string) sql.NullString {
-	return sql.NullString{String: value, Valid: value != ""}
-}
-
 // HandleAppUpdate handles app updates.
 func (h *Handlers) HandleAppUpdate() http.HandlerFunc { //nolint:funlen // validation adds necessary length
 	tmpl := templates.GetParsed()
@@ -268,7 +260,17 @@ func (h *Handlers) HandleAppUpdate() http.HandlerFunc { //nolint:funlen // valid
 		application.DockerNetwork = optionalNullString(request.FormValue("docker_network"))
 		application.NtfyTopic = optionalNullString(request.FormValue("ntfy_topic"))
 		application.SlackWebhook = optionalNullString(request.FormValue("slack_webhook"))
-		application.HealthcheckCommand = optionalNullString(request.FormValue("healthcheck_command"))
+
+		limitsErr := applyResourceLimits(application, request)
+		if limitsErr != "" {
+			data := h.addGlobals(map[string]any{
+				"App":   application,
+				"Error": limitsErr,
+			}, request)
+			h.renderTemplate(writer, tmpl, "app_edit.html", data)
+
+			return
+		}
 
 		saveErr := application.Save(request.Context())
 		if saveErr != nil {
@@ -1362,6 +1364,129 @@ func validateVolumePaths(hostPath, containerPath string) error {
 	return nil
 }
 
+// ErrInvalidMemoryFormat is returned when a memory limit string cannot be parsed.
+var ErrInvalidMemoryFormat = errors.New(
+	"must be a number with optional unit suffix (e.g. 256m, 1g, 512000000)",
+)
+
+// ErrNegativeValue is returned when a resource limit is negative.
+var ErrNegativeValue = errors.New("value must be positive")
+
+// Memory unit byte multipliers.
+const (
+	kilobyte = 1024
+	megabyte = 1024 * 1024
+	gigabyte = 1024 * 1024 * 1024
+)
+
+// optionalNullString converts a form value to a sql.NullString.
+// Returns a valid NullString if non-empty, invalid (NULL) if empty.
+func optionalNullString(s string) sql.NullString {
+	if s != "" {
+		return sql.NullString{String: s, Valid: true}
+	}
+
+	return sql.NullString{}
+}
+
+// applyResourceLimits parses CPU and memory limit form values and applies them to the app.
+// Returns an error message string if validation fails, or empty string on success.
+func applyResourceLimits(application *models.App, request *http.Request) string {
+	cpuLimit, cpuErr := parseOptionalFloat64(request.FormValue("cpu_limit"))
+	if cpuErr != nil {
+		return "Invalid CPU limit: must be a positive number (e.g. 0.5, 1, 2)"
+	}
+
+	application.CPULimit = cpuLimit
+
+	memoryLimit, memErr := parseOptionalMemoryBytes(request.FormValue("memory_limit"))
+	if memErr != nil {
+		return "Invalid memory limit: " + memErr.Error()
+	}
+
+	application.MemoryLimit = memoryLimit
+
+	return ""
+}
+
+// memoryUnitMultiplier returns the byte multiplier for a memory unit suffix.
+// Returns 0 if the suffix is not recognized.
+func memoryUnitMultiplier(suffix byte) int64 {
+	switch suffix {
+	case 'k':
+		return kilobyte
+	case 'm':
+		return megabyte
+	case 'g':
+		return gigabyte
+	default:
+		return 0
+	}
+}
+
+// parseOptionalFloat64 parses an optional float64 form field.
+// Returns a valid NullFloat64 if the string is non-empty and parses to a positive number.
+// Returns an empty NullFloat64 if the string is empty.
+// Returns an error if the string is non-empty but invalid or non-positive.
+func parseOptionalFloat64(s string) (sql.NullFloat64, error) {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return sql.NullFloat64{}, nil
+	}
+
+	val, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return sql.NullFloat64{}, fmt.Errorf("invalid number: %w", err)
+	}
+
+	if val <= 0 {
+		return sql.NullFloat64{}, ErrNegativeValue
+	}
+
+	return sql.NullFloat64{Float64: val, Valid: true}, nil
+}
+
+// parseOptionalMemoryBytes parses an optional memory limit string into bytes.
+// Accepts plain bytes (e.g. "536870912") or suffixed values (e.g. "512m", "1g", "256k").
+// Returns a valid NullInt64 with bytes if non-empty, empty NullInt64 if blank.
+func parseOptionalMemoryBytes(s string) (sql.NullInt64, error) {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return sql.NullInt64{}, nil
+	}
+
+	s = strings.ToLower(s)
+
+	// Check for unit suffix
+	multiplier := memoryUnitMultiplier(s[len(s)-1])
+	if multiplier > 0 {
+		numStr := s[:len(s)-1]
+
+		val, err := strconv.ParseFloat(numStr, 64)
+		if err != nil {
+			return sql.NullInt64{}, ErrInvalidMemoryFormat
+		}
+
+		if val <= 0 {
+			return sql.NullInt64{}, ErrNegativeValue
+		}
+
+		return sql.NullInt64{Int64: int64(val * float64(multiplier)), Valid: true}, nil
+	}
+
+	// Plain bytes
+	val, err := strconv.ParseInt(s, 10, 64)
+	if err != nil {
+		return sql.NullInt64{}, ErrInvalidMemoryFormat
+	}
+
+	if val <= 0 {
+		return sql.NullInt64{}, ErrNegativeValue
+	}
+
+	return sql.NullInt64{Int64: val, Valid: true}, nil
+}
+
 // formatDeployKey formats an SSH public key with a descriptive comment.
 // Format: ssh-ed25519 AAAA... upaas_2025-01-15_myapp
 func formatDeployKey(pubKey string, createdAt time.Time, appName string) string {

internal/handlers/resource_limits_test.go

@@ -0,0 +1,195 @@
+package handlers //nolint:testpackage // tests unexported parsing functions
+
+import (
+	"database/sql"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestParseOptionalFloat64(t *testing.T) {
+	t.Parallel()
+
+	t.Run("empty string returns invalid", func(t *testing.T) {
+		t.Parallel()
+
+		result, err := parseOptionalFloat64("")
+		require.NoError(t, err)
+		assert.False(t, result.Valid)
+	})
+
+	t.Run("whitespace only returns invalid", func(t *testing.T) {
+		t.Parallel()
+
+		result, err := parseOptionalFloat64("   ")
+		require.NoError(t, err)
+		assert.False(t, result.Valid)
+	})
+
+	t.Run("valid float", func(t *testing.T) {
+		t.Parallel()
+
+		result, err := parseOptionalFloat64("0.5")
+		require.NoError(t, err)
+		assert.True(t, result.Valid)
+		assert.InDelta(t, 0.5, result.Float64, 0.001)
+	})
+
+	t.Run("valid integer", func(t *testing.T) {
+		t.Parallel()
+
+		result, err := parseOptionalFloat64("2")
+		require.NoError(t, err)
+		assert.True(t, result.Valid)
+		assert.InDelta(t, 2.0, result.Float64, 0.001)
+	})
+
+	t.Run("negative value rejected", func(t *testing.T) {
+		t.Parallel()
+
+		_, err := parseOptionalFloat64("-1")
+		require.Error(t, err)
+	})
+
+	t.Run("zero value rejected", func(t *testing.T) {
+		t.Parallel()
+
+		_, err := parseOptionalFloat64("0")
+		require.Error(t, err)
+	})
+
+	t.Run("non-numeric rejected", func(t *testing.T) {
+		t.Parallel()
+
+		_, err := parseOptionalFloat64("abc")
+		require.Error(t, err)
+	})
+}
+
+func TestParseOptionalMemoryBytes(t *testing.T) { //nolint:funlen // table-driven test
+	t.Parallel()
+
+	t.Run("empty string returns invalid", func(t *testing.T) {
+		t.Parallel()
+
+		result, err := parseOptionalMemoryBytes("")
+		require.NoError(t, err)
+		assert.False(t, result.Valid)
+	})
+
+	t.Run("whitespace only returns invalid", func(t *testing.T) {
+		t.Parallel()
+
+		result, err := parseOptionalMemoryBytes("   ")
+		require.NoError(t, err)
+		assert.False(t, result.Valid)
+	})
+
+	t.Run("plain bytes", func(t *testing.T) {
+		t.Parallel()
+
+		result, err := parseOptionalMemoryBytes("536870912")
+		require.NoError(t, err)
+		assert.True(t, result.Valid)
+		assert.Equal(t, int64(536870912), result.Int64)
+	})
+
+	t.Run("megabytes suffix", func(t *testing.T) {
+		t.Parallel()
+
+		result, err := parseOptionalMemoryBytes("256m")
+		require.NoError(t, err)
+		assert.True(t, result.Valid)
+		assert.Equal(t, int64(256*1024*1024), result.Int64)
+	})
+
+	t.Run("megabytes suffix uppercase", func(t *testing.T) {
+		t.Parallel()
+
+		result, err := parseOptionalMemoryBytes("256M")
+		require.NoError(t, err)
+		assert.True(t, result.Valid)
+		assert.Equal(t, int64(256*1024*1024), result.Int64)
+	})
+
+	t.Run("gigabytes suffix", func(t *testing.T) {
+		t.Parallel()
+
+		result, err := parseOptionalMemoryBytes("1g")
+		require.NoError(t, err)
+		assert.True(t, result.Valid)
+		assert.Equal(t, int64(1024*1024*1024), result.Int64)
+	})
+
+	t.Run("kilobytes suffix", func(t *testing.T) {
+		t.Parallel()
+
+		result, err := parseOptionalMemoryBytes("512k")
+		require.NoError(t, err)
+		assert.True(t, result.Valid)
+		assert.Equal(t, int64(512*1024), result.Int64)
+	})
+
+	t.Run("fractional gigabytes", func(t *testing.T) {
+		t.Parallel()
+
+		result, err := parseOptionalMemoryBytes("1.5g")
+		require.NoError(t, err)
+		assert.True(t, result.Valid)
+		assert.Equal(t, int64(1.5*1024*1024*1024), result.Int64)
+	})
+
+	t.Run("negative value rejected", func(t *testing.T) {
+		t.Parallel()
+
+		_, err := parseOptionalMemoryBytes("-256m")
+		require.Error(t, err)
+	})
+
+	t.Run("zero value rejected", func(t *testing.T) {
+		t.Parallel()
+
+		_, err := parseOptionalMemoryBytes("0")
+		require.Error(t, err)
+	})
+
+	t.Run("invalid string rejected", func(t *testing.T) {
+		t.Parallel()
+
+		_, err := parseOptionalMemoryBytes("abc")
+		require.Error(t, err)
+	})
+
+	t.Run("negative plain bytes rejected", func(t *testing.T) {
+		t.Parallel()
+
+		_, err := parseOptionalMemoryBytes("-100")
+		require.Error(t, err)
+	})
+}
+
+func TestAppResourceLimitsRoundTrip(t *testing.T) {
+	t.Parallel()
+
+	// Test that parsing and formatting are consistent
+	tests := []struct {
+		input    string
+		expected sql.NullInt64
+		format   string
+	}{
+		{"256m", sql.NullInt64{Int64: 256 * 1024 * 1024, Valid: true}, "256m"},
+		{"1g", sql.NullInt64{Int64: 1024 * 1024 * 1024, Valid: true}, "1g"},
+		{"512k", sql.NullInt64{Int64: 512 * 1024, Valid: true}, "512k"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.input, func(t *testing.T) {
+			t.Parallel()
+
+			result, err := parseOptionalMemoryBytes(tt.input)
+			require.NoError(t, err)
+			assert.Equal(t, tt.expected, result)
+		})
+	}
+}

internal/models/app.go

@@ -14,7 +14,8 @@ import (
 const appColumns = `id, name, repo_url, branch, dockerfile_path, webhook_secret,
 			ssh_private_key, ssh_public_key, image_id, status,
 			docker_network, ntfy_topic, slack_webhook, webhook_secret_hash,
-			previous_image_id, healthcheck_command, created_at, updated_at`
+			previous_image_id, cpu_limit, memory_limit,
+			created_at, updated_at`
 
 // AppStatus represents the status of an app.
 type AppStatus string
@@ -32,24 +33,25 @@ const (
 type App struct {
 	db *database.Database
 
-	ID                 string
+	ID                string
-	Name               string
+	Name              string
-	RepoURL            string
+	RepoURL           string
-	Branch             string
+	Branch            string
-	DockerfilePath     string
+	DockerfilePath    string
-	WebhookSecret      string
+	WebhookSecret     string
-	WebhookSecretHash  string
+	WebhookSecretHash string
-	SSHPrivateKey      string
+	SSHPrivateKey     string
-	SSHPublicKey       string
+	SSHPublicKey      string
-	ImageID            sql.NullString
+	ImageID           sql.NullString
-	PreviousImageID    sql.NullString
+	PreviousImageID   sql.NullString
-	Status             AppStatus
+	Status            AppStatus
-	DockerNetwork      sql.NullString
+	DockerNetwork     sql.NullString
-	NtfyTopic          sql.NullString
+	NtfyTopic         sql.NullString
-	SlackWebhook       sql.NullString
+	SlackWebhook      sql.NullString
-	HealthcheckCommand sql.NullString
+	CPULimit          sql.NullFloat64
-	CreatedAt          time.Time
+	MemoryLimit       sql.NullInt64
-	UpdatedAt          time.Time
+	CreatedAt         time.Time
+	UpdatedAt         time.Time
 }
 
 // NewApp creates a new App with a database reference.
@@ -143,14 +145,14 @@ func (a *App) insert(ctx context.Context) error {
 			id, name, repo_url, branch, dockerfile_path, webhook_secret,
 			ssh_private_key, ssh_public_key, image_id, status,
 			docker_network, ntfy_topic, slack_webhook, webhook_secret_hash,
-			previous_image_id, healthcheck_command
+			previous_image_id, cpu_limit, memory_limit
-		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+		) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
 
 	_, err := a.db.Exec(ctx, query,
 		a.ID, a.Name, a.RepoURL, a.Branch, a.DockerfilePath, a.WebhookSecret,
 		a.SSHPrivateKey, a.SSHPublicKey, a.ImageID, a.Status,
 		a.DockerNetwork, a.NtfyTopic, a.SlackWebhook, a.WebhookSecretHash,
-		a.PreviousImageID, a.HealthcheckCommand,
+		a.PreviousImageID, a.CPULimit, a.MemoryLimit,
 	)
 	if err != nil {
 		return err
@@ -165,7 +167,8 @@ func (a *App) update(ctx context.Context) error {
 			name = ?, repo_url = ?, branch = ?, dockerfile_path = ?,
 			image_id = ?, status = ?,
 			docker_network = ?, ntfy_topic = ?, slack_webhook = ?,
-			previous_image_id = ?, healthcheck_command = ?,
+			previous_image_id = ?,
+			cpu_limit = ?, memory_limit = ?,
 			updated_at = CURRENT_TIMESTAMP
 		WHERE id = ?`
 
@@ -173,7 +176,8 @@ func (a *App) update(ctx context.Context) error {
 		a.Name, a.RepoURL, a.Branch, a.DockerfilePath,
 		a.ImageID, a.Status,
 		a.DockerNetwork, a.NtfyTopic, a.SlackWebhook,
-		a.PreviousImageID, a.HealthcheckCommand,
+		a.PreviousImageID,
+		a.CPULimit, a.MemoryLimit,
 		a.ID,
 	)
 
@@ -188,7 +192,8 @@ func (a *App) scan(row *sql.Row) error {
 		&a.ImageID, &a.Status,
 		&a.DockerNetwork, &a.NtfyTopic, &a.SlackWebhook,
 		&a.WebhookSecretHash,
-		&a.PreviousImageID, &a.HealthcheckCommand,
+		&a.PreviousImageID,
+		&a.CPULimit, &a.MemoryLimit,
 		&a.CreatedAt, &a.UpdatedAt,
 	)
 }
@@ -206,7 +211,8 @@ func scanApps(appDB *database.Database, rows *sql.Rows) ([]*App, error) {
 			&app.ImageID, &app.Status,
 			&app.DockerNetwork, &app.NtfyTopic, &app.SlackWebhook,
 			&app.WebhookSecretHash,
-			&app.PreviousImageID, &app.HealthcheckCommand,
+			&app.PreviousImageID,
+			&app.CPULimit, &app.MemoryLimit,
 			&app.CreatedAt, &app.UpdatedAt,
 		)
 		if scanErr != nil {

internal/models/models_test.go

@@ -704,72 +704,6 @@ func TestAppGetWebhookEvents(t *testing.T) {
 	assert.Len(t, events, 1)
 }
 
-// App HealthcheckCommand Tests.
-
-func TestAppHealthcheckCommand(t *testing.T) {
-	t.Parallel()
-
-	t.Run("saves and loads healthcheck command", func(t *testing.T) {
-		t.Parallel()
-
-		testDB, cleanup := setupTestDB(t)
-		defer cleanup()
-
-		app := createTestApp(t, testDB)
-		app.HealthcheckCommand = sql.NullString{
-			String: "curl -f http://localhost:8080/healthz || exit 1",
-			Valid:  true,
-		}
-
-		err := app.Save(context.Background())
-		require.NoError(t, err)
-
-		found, err := models.FindApp(context.Background(), testDB, app.ID)
-		require.NoError(t, err)
-		require.NotNil(t, found)
-		assert.True(t, found.HealthcheckCommand.Valid)
-		assert.Equal(t, "curl -f http://localhost:8080/healthz || exit 1", found.HealthcheckCommand.String)
-	})
-
-	t.Run("null when not set", func(t *testing.T) {
-		t.Parallel()
-
-		testDB, cleanup := setupTestDB(t)
-		defer cleanup()
-
-		app := createTestApp(t, testDB)
-
-		found, err := models.FindApp(context.Background(), testDB, app.ID)
-		require.NoError(t, err)
-		require.NotNil(t, found)
-		assert.False(t, found.HealthcheckCommand.Valid)
-	})
-
-	t.Run("can be cleared", func(t *testing.T) {
-		t.Parallel()
-
-		testDB, cleanup := setupTestDB(t)
-		defer cleanup()
-
-		app := createTestApp(t, testDB)
-		app.HealthcheckCommand = sql.NullString{String: "true", Valid: true}
-
-		err := app.Save(context.Background())
-		require.NoError(t, err)
-
-		// Clear it
-		app.HealthcheckCommand = sql.NullString{}
-
-		err = app.Save(context.Background())
-		require.NoError(t, err)
-
-		found, err := models.FindApp(context.Background(), testDB, app.ID)
-		require.NoError(t, err)
-		require.NotNil(t, found)
-		assert.False(t, found.HealthcheckCommand.Valid)
-	})
-}
-
 // Cascade Delete Tests.
 
 //nolint:funlen // Test function with many assertions - acceptable for integration tests
@@ -847,6 +781,96 @@ func TestCascadeDelete(t *testing.T) {
 	})
 }
 
+// Resource Limits Tests.
+
+func TestAppResourceLimits(t *testing.T) { //nolint:funlen // integration test with multiple subtests
+	t.Parallel()
+
+	t.Run("saves and loads CPU limit", func(t *testing.T) {
+		t.Parallel()
+
+		testDB, cleanup := setupTestDB(t)
+		defer cleanup()
+
+		app := createTestApp(t, testDB)
+
+		app.CPULimit = sql.NullFloat64{Float64: 0.5, Valid: true}
+
+		err := app.Save(context.Background())
+		require.NoError(t, err)
+
+		found, err := models.FindApp(context.Background(), testDB, app.ID)
+		require.NoError(t, err)
+		require.NotNil(t, found)
+		assert.True(t, found.CPULimit.Valid)
+		assert.InDelta(t, 0.5, found.CPULimit.Float64, 0.001)
+	})
+
+	t.Run("saves and loads memory limit", func(t *testing.T) {
+		t.Parallel()
+
+		testDB, cleanup := setupTestDB(t)
+		defer cleanup()
+
+		app := createTestApp(t, testDB)
+
+		app.MemoryLimit = sql.NullInt64{Int64: 536870912, Valid: true} // 512m
+
+		err := app.Save(context.Background())
+		require.NoError(t, err)
+
+		found, err := models.FindApp(context.Background(), testDB, app.ID)
+		require.NoError(t, err)
+		require.NotNil(t, found)
+		assert.True(t, found.MemoryLimit.Valid)
+		assert.Equal(t, int64(536870912), found.MemoryLimit.Int64)
+	})
+
+	t.Run("null limits by default", func(t *testing.T) {
+		t.Parallel()
+
+		testDB, cleanup := setupTestDB(t)
+		defer cleanup()
+
+		app := createTestApp(t, testDB)
+
+		found, err := models.FindApp(context.Background(), testDB, app.ID)
+		require.NoError(t, err)
+		require.NotNil(t, found)
+		assert.False(t, found.CPULimit.Valid)
+		assert.False(t, found.MemoryLimit.Valid)
+	})
+
+	t.Run("clears limits when set to null", func(t *testing.T) {
+		t.Parallel()
+
+		testDB, cleanup := setupTestDB(t)
+		defer cleanup()
+
+		app := createTestApp(t, testDB)
+
+		// Set limits
+		app.CPULimit = sql.NullFloat64{Float64: 1.0, Valid: true}
+		app.MemoryLimit = sql.NullInt64{Int64: 1073741824, Valid: true} // 1g
+
+		err := app.Save(context.Background())
+		require.NoError(t, err)
+
+		// Clear limits
+		app.CPULimit = sql.NullFloat64{}
+		app.MemoryLimit = sql.NullInt64{}
+
+		err = app.Save(context.Background())
+		require.NoError(t, err)
+
+		found, err := models.FindApp(context.Background(), testDB, app.ID)
+		require.NoError(t, err)
+		require.NotNil(t, found)
+		assert.False(t, found.CPULimit.Valid)
+		assert.False(t, found.MemoryLimit.Valid)
+	})
+}
+
 // Helper function to create a test app.
 func createTestApp(t *testing.T, testDB *database.Database) *models.App {
 	t.Helper()

internal/service/app/app.go

@@ -46,14 +46,13 @@ func New(_ fx.Lifecycle, params ServiceParams) (*Service, error) {
 
 // CreateAppInput contains the input for creating an app.
 type CreateAppInput struct {
-	Name               string
+	Name           string
-	RepoURL            string
+	RepoURL        string
-	Branch             string
+	Branch         string
-	DockerfilePath     string
+	DockerfilePath string
-	DockerNetwork      string
+	DockerNetwork  string
-	NtfyTopic          string
+	NtfyTopic      string
-	SlackWebhook       string
+	SlackWebhook   string
-	HealthcheckCommand string
 }
 
 // CreateApp creates a new application with generated SSH keys and webhook secret.
@@ -101,10 +100,6 @@ func (svc *Service) CreateApp(
 		app.SlackWebhook = sql.NullString{String: input.SlackWebhook, Valid: true}
 	}
 
-	if input.HealthcheckCommand != "" {
-		app.HealthcheckCommand = sql.NullString{String: input.HealthcheckCommand, Valid: true}
-	}
-
 	saveErr := app.Save(ctx)
 	if saveErr != nil {
 		return nil, fmt.Errorf("failed to save app: %w", saveErr)
@@ -117,14 +112,13 @@ func (svc *Service) CreateApp(
 
 // UpdateAppInput contains the input for updating an app.
 type UpdateAppInput struct {
-	Name               string
+	Name           string
-	RepoURL            string
+	RepoURL        string
-	Branch             string
+	Branch         string
-	DockerfilePath     string
+	DockerfilePath string
-	DockerNetwork      string
+	DockerNetwork  string
-	NtfyTopic          string
+	NtfyTopic      string
-	SlackWebhook       string
+	SlackWebhook   string
-	HealthcheckCommand string
 }
 
 // UpdateApp updates an existing application.
@@ -150,10 +144,6 @@ func (svc *Service) UpdateApp(
 		String: input.SlackWebhook,
 		Valid:  input.SlackWebhook != "",
 	}
-	app.HealthcheckCommand = sql.NullString{
-		String: input.HealthcheckCommand,
-		Valid:  input.HealthcheckCommand != "",
-	}
 
 	saveErr := app.Save(ctx)
 	if saveErr != nil {

internal/service/deploy/deploy.go

@@ -1094,20 +1094,28 @@ func (svc *Service) buildContainerOptions(
 		network = app.DockerNetwork.String
 	}
 
-	healthcheckCmd := ""
+	var cpuLimit float64
-	if app.HealthcheckCommand.Valid {
+
-		healthcheckCmd = app.HealthcheckCommand.String
+	if app.CPULimit.Valid {
+		cpuLimit = app.CPULimit.Float64
+	}
+
+	var memoryLimit int64
+
+	if app.MemoryLimit.Valid {
+		memoryLimit = app.MemoryLimit.Int64
 	}
 
 	return docker.CreateContainerOptions{
-		Name:               "upaas-" + app.Name,
+		Name:        "upaas-" + app.Name,
-		Image:              imageID.String(),
+		Image:       imageID.String(),
-		Env:                envMap,
+		Env:         envMap,
-		Labels:             buildLabelMap(app, labels),
+		Labels:      buildLabelMap(app, labels),
-		Volumes:            buildVolumeMounts(volumes),
+		Volumes:     buildVolumeMounts(volumes),
-		Ports:              buildPortMappings(ports),
+		Ports:       buildPortMappings(ports),
-		Network:            network,
+		Network:     network,
-		HealthcheckCommand: healthcheckCmd,
+		CPULimit:    cpuLimit,
+		MemoryLimit: memoryLimit,
 	}, nil
 }
 

internal/service/deploy/deploy_container_test.go

@@ -45,17 +45,13 @@ func TestBuildContainerOptionsUsesImageID(t *testing.T) {
 	}
 }
 
-func TestBuildContainerOptionsHealthcheckSet(t *testing.T) {
+func TestBuildContainerOptionsNoResourceLimits(t *testing.T) {
 	t.Parallel()
 
 	db := database.NewTestDatabase(t)
 
 	app := models.NewApp(db)
-	app.Name = "hc-app"
+	app.Name = "nolimits"
-	app.HealthcheckCommand = sql.NullString{
-		String: "curl -f http://localhost:8080/healthz || exit 1",
-		Valid:  true,
-	}
 
 	err := app.Save(context.Background())
 	if err != nil {
@@ -66,25 +62,29 @@ func TestBuildContainerOptionsHealthcheckSet(t *testing.T) {
 	svc := deploy.NewTestService(log)
 
 	opts, err := svc.BuildContainerOptionsExported(
-		context.Background(), app, "sha256:test",
+		context.Background(), app, docker.ImageID("test:latest"),
 	)
 	if err != nil {
 		t.Fatalf("buildContainerOptions returned error: %v", err)
 	}
 
-	expected := "curl -f http://localhost:8080/healthz || exit 1"
+	if opts.CPULimit != 0 {
-	if opts.HealthcheckCommand != expected {
+		t.Errorf("expected CPULimit=0, got %v", opts.CPULimit)
-		t.Errorf("expected HealthcheckCommand=%q, got %q", expected, opts.HealthcheckCommand)
+	}
+
+	if opts.MemoryLimit != 0 {
+		t.Errorf("expected MemoryLimit=0, got %v", opts.MemoryLimit)
 	}
 }
 
-func TestBuildContainerOptionsHealthcheckEmpty(t *testing.T) {
+func TestBuildContainerOptionsCPULimit(t *testing.T) {
 	t.Parallel()
 
 	db := database.NewTestDatabase(t)
 
 	app := models.NewApp(db)
-	app.Name = "no-hc-app"
+	app.Name = "cpulimit"
+	app.CPULimit = sql.NullFloat64{Float64: 0.5, Valid: true}
 
 	err := app.Save(context.Background())
 	if err != nil {
@@ -95,13 +95,42 @@ func TestBuildContainerOptionsHealthcheckEmpty(t *testing.T) {
 	svc := deploy.NewTestService(log)
 
 	opts, err := svc.BuildContainerOptionsExported(
-		context.Background(), app, "sha256:test",
+		context.Background(), app, docker.ImageID("test:latest"),
 	)
 	if err != nil {
 		t.Fatalf("buildContainerOptions returned error: %v", err)
 	}
 
-	if opts.HealthcheckCommand != "" {
+	if opts.CPULimit != 0.5 {
-		t.Errorf("expected empty HealthcheckCommand, got %q", opts.HealthcheckCommand)
+		t.Errorf("expected CPULimit=0.5, got %v", opts.CPULimit)
+	}
+}
+
+func TestBuildContainerOptionsMemoryLimit(t *testing.T) {
+	t.Parallel()
+
+	db := database.NewTestDatabase(t)
+
+	app := models.NewApp(db)
+	app.Name = "memlimit"
+	app.MemoryLimit = sql.NullInt64{Int64: 536870912, Valid: true} // 512m
+
+	err := app.Save(context.Background())
+	if err != nil {
+		t.Fatalf("failed to save app: %v", err)
+	}
+
+	log := slog.New(slog.NewTextHandler(os.Stderr, nil))
+	svc := deploy.NewTestService(log)
+
+	opts, err := svc.BuildContainerOptionsExported(
+		context.Background(), app, docker.ImageID("test:latest"),
+	)
+	if err != nil {
+		t.Fatalf("buildContainerOptions returned error: %v", err)
+	}
+
+	if opts.MemoryLimit != 536870912 {
+		t.Errorf("expected MemoryLimit=536870912, got %v", opts.MemoryLimit)
 	}
 }

templates/app_edit.html

@@ -114,17 +114,36 @@
                 >
             </div>
 
-            <div class="form-group">
+            <hr class="border-gray-200">
-                <label for="healthcheck_command" class="label">Health Check Command</label>
+
-                <input
+            <h3 class="text-lg font-medium text-gray-900">Resource Limits</h3>
-                    type="text"
+
-                    id="healthcheck_command"
+            <div class="grid grid-cols-2 gap-4">
-                    name="healthcheck_command"
+                <div class="form-group">
-                    value="{{if .App.HealthcheckCommand.Valid}}{{.App.HealthcheckCommand.String}}{{end}}"
+                    <label for="cpu_limit" class="label">CPU Limit (cores)</label>
-                    class="input font-mono"
+                    <input
-                    placeholder="curl -f http://localhost:8080/healthz || exit 1"
+                        type="text"
-                >
+                        id="cpu_limit"
-                <p class="text-sm text-gray-500 mt-1">Custom shell command to check container health. Leave empty to use the image's default health check.</p>
+                        name="cpu_limit"
+                        value="{{if .App.CPULimit.Valid}}{{.App.CPULimit.Float64}}{{end}}"
+                        class="input"
+                        placeholder="e.g. 0.5, 1, 2"
+                    >
+                    <p class="text-sm text-gray-500 mt-1">Number of CPU cores (e.g. 0.5 = half a core)</p>
+                </div>
+
+                <div class="form-group">
+                    <label for="memory_limit" class="label">Memory Limit</label>
+                    <input
+                        type="text"
+                        id="memory_limit"
+                        name="memory_limit"
+                        value="{{if .App.MemoryLimit.Valid}}{{formatMemoryBytes .App.MemoryLimit.Int64}}{{end}}"
+                        class="input"
+                        placeholder="e.g. 256m, 1g"
+                    >
+                    <p class="text-sm text-gray-500 mt-1">Memory with unit suffix (k, m, g) or plain bytes</p>
+                </div>
             </div>
 
             <div class="flex justify-end gap-3 pt-4">

templates/app_new.html

@@ -117,19 +117,6 @@
                 >
             </div>
 
-            <div class="form-group">
-                <label for="healthcheck_command" class="label">Health Check Command</label>
-                <input
-                    type="text"
-                    id="healthcheck_command"
-                    name="healthcheck_command"
-                    value="{{.HealthcheckCommand}}"
-                    class="input font-mono"
-                    placeholder="curl -f http://localhost:8080/healthz || exit 1"
-                >
-                <p class="text-sm text-gray-500 mt-1">Custom shell command to check container health. Leave empty to use the image's default health check.</p>
-            </div>
-
             <div class="flex justify-end gap-3 pt-4">
                 <a href="/" class="btn-secondary">Cancel</a>
                 <button type="submit" class="btn-primary">Create App</button>

templates/templates.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"html/template"
 	"io"
+	"strconv"
 	"sync"
 )
 
@@ -23,6 +24,34 @@ var (
 	templatesMutex sync.RWMutex
 )
 
+// templateFuncs returns the custom template function map.
+func templateFuncs() template.FuncMap {
+	return template.FuncMap{
+		"formatMemoryBytes": formatMemoryBytes,
+	}
+}
+
+// Memory unit constants.
+const (
+	memGigabyte = 1024 * 1024 * 1024
+	memMegabyte = 1024 * 1024
+	memKilobyte = 1024
+)
+
+// formatMemoryBytes formats bytes into a human-readable string with unit suffix.
+func formatMemoryBytes(bytes int64) string {
+	switch {
+	case bytes >= memGigabyte && bytes%memGigabyte == 0:
+		return strconv.FormatInt(bytes/memGigabyte, 10) + "g"
+	case bytes >= memMegabyte && bytes%memMegabyte == 0:
+		return strconv.FormatInt(bytes/memMegabyte, 10) + "m"
+	case bytes >= memKilobyte && bytes%memKilobyte == 0:
+		return strconv.FormatInt(bytes/memKilobyte, 10) + "k"
+	default:
+		return strconv.FormatInt(bytes, 10)
+	}
+}
+
 // initTemplates parses base template and creates cloned templates for each page.
 func initTemplates() {
 	templatesMutex.Lock()
@@ -32,8 +61,10 @@ func initTemplates() {
 		return
 	}
 
-	// Parse base template with shared components
+	// Parse base template with shared components and custom functions
-	baseTemplate = template.Must(template.ParseFS(templatesRaw, "base.html"))
+	baseTemplate = template.Must(
+		template.New("base.html").Funcs(templateFuncs()).ParseFS(templatesRaw, "base.html"),
+	)
 
 	// Pages that extend base
 	pages := []string{

templates/templates_test.go

@@ -0,0 +1,34 @@
+package templates //nolint:testpackage // tests unexported formatMemoryBytes
+
+import (
+	"testing"
+)
+
+func TestFormatMemoryBytes(t *testing.T) {
+	t.Parallel()
+
+	tests := []struct {
+		name     string
+		bytes    int64
+		expected string
+	}{
+		{"gigabytes", 1024 * 1024 * 1024, "1g"},
+		{"two gigabytes", 2 * 1024 * 1024 * 1024, "2g"},
+		{"megabytes", 256 * 1024 * 1024, "256m"},
+		{"kilobytes", 512 * 1024, "512k"},
+		{"plain bytes", 12345, "12345"},
+		{"non-even megabytes", 256*1024*1024 + 1, "268435457"},
+		{"zero", 0, "0"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+
+			got := formatMemoryBytes(tt.bytes)
+			if got != tt.expected {
+				t.Errorf("formatMemoryBytes(%d) = %q, want %q", tt.bytes, got, tt.expected)
+			}
+		})
+	}
+}