Application Architecture

Learn go application architecture through an executable example, then connect the small demonstration to production code.

Architecture separates concerns: the entry point wires dependencies, a service applies business rules, and storage adapters deal with persistence. Start small and introduce boundaries when they simplify testing or change.

The example uses a store interface and an in-memory implementation. This is one possible design rather than a framework Go requires.

Follow this diagram before executing the example. Check where a value or decision changes what runs next.

For larger apps, an entry point under cmd/ can wire application services under internal/. Official layout guidance: Organizing a Go module.

This example is a complete program. Save it as main.go or paste it into the Go Playground.

Go code

package main

import (
	"fmt"
	"strings"
)

type Store interface{ Save(string) error }
type MemoryStore struct{ Items []string }

func (m *MemoryStore) Save(s string) error { m.Items = append(m.Items, s); return nil }

type Service struct{ Store Store }

func (s Service) Add(name string) error {
	name = strings.TrimSpace(name)
	if name == "" {
		return fmt.Errorf("name is empty")
	}
	return s.Store.Save(name)
}
func main() {
	memory := &MemoryStore{}
	service := Service{Store: memory}
	fmt.Println("Error:", service.Add(" Ada "))
	fmt.Println("Saved:", memory.Items)
}

Output

Error: <nil>
Saved: [Ada]

The service trims and validates Ada, then calls its Store interface. The MemoryStore appends Ada and returns nil; the entry point prints the saved item.

• Do not turn every function into a separate package or interface.
• Avoid placing validation and database calls directly into unrelated HTTP handlers.

Add a second Store implementation that rejects duplicate names; keep Service unchanged.

Tip: Edit the example above, predict the output, and run the modified code to test your reasoning.

You have practiced Go Application Architecture in a small, self-contained program. The important habit is to predict what runs, inspect the actual output and distinguish the language rule from the particular example.

Before continuing, make sure you can explain the program to someone who has not seen it, including the line that changes its result.