跪拜 Guibai
← Back to the summary

Backend Progression: A Four-Level Chart That Replaces Years with Deliverables

Backend Progression Path: From Writing CRUD to Defining Architecture, One Chart Explains It All

1. First Look at the Change: A Four-Level Backend Tech Stack Upgrade Comparison Table

The essence of progression is changing your stack: each level eliminates the practices of the previous level. This table is the skeleton; we'll expand each cell below.

Dimension Junior · Can Write Mid · Writes Well Senior · Designs for Stability Staff · Can Lead
Interfaces Write CRUD per requirements Unified standards + parameter validation Contract-first, idempotency design Set interface governance standards
Data Direct SQL ORM + index optimization Database sharding, read-write splitting Set data architecture
Caching Not used or misused Redis basic caching usage Cache consistency, penetration/avalanche handling Set multi-level caching system
Concurrency Serial processing Thread pool / connection pool Message queue peak shaving, rate limiting Set capacity and degradation strategies
Deployment Manual package upload Docker containerization K8s orchestration, canary releases Set release and rollback standards
Observability Rely on print and logs Structured logging Metrics + tracing + alerts Set SLO and error budgets
Testing Manual API testing Unit tests + integration tests Contract tests + load testing Set quality gates
Output A runnable interface A maintainable service A system that can withstand traffic A set of replicable architecture decisions

Read the table: wherever you're stuck, look at which column still uses the previous level's practices.

2. Junior → Mid: From "It Runs" to "Written Well"

This jump replaces three things: raw SQL with ORM, scattered interfaces with unified standards, manual deployment with containers.

Stack change 1: ORM + Index. Using Go + GORM as an example, models and queries carry types and constraints:

type User struct {
  ID   uint   `gorm:"primaryKey"`
  Name string `gorm:"size:64;not null;index"`
}
// Indexed query, avoid SELECT *
db.Where("name = ?", name).First(&user)

Stack change 2: Unified response and validation. Don't let each interface write its own return format:

type Resp[T any] struct {
  Code int    `json:"code"`
  Msg  string `json:"msg"`
  Data T      `json:"data"`
}

Stack change 3: Containerization. A minimal Dockerfile that separates build and run:

FROM golang:1.22 AS build
WORKDIR /src
COPY . .
RUN CGO_ENABLED=0 go build -o app .
FROM alpine:3.20
COPY --from=build /src/app /app
CMD ["/app"]

Acceptance criteria are strict: unified response, indexed queries, one command to start the container.

3. Mid → Senior: From "Written Well" to "Designed for Stability"

This jump no longer dwells on single interfaces; it's about making the system withstand traffic and being able to locate issues.

Stack change 1: Cache + consistency. Standard cache-aside pattern with expiration to prevent avalanche:

func GetUser(id uint) (User, error) {
  key := fmt.Sprintf("user:%d", id)
  if v, err := rdb.Get(ctx, key).Result(); err == nil {
    return decode(v)
  }
  u, err := db.First(&User{}, id).Error
  if err == nil {
    rdb.Set(ctx, key, encode(u), 10*time.Minute+jitter())
  }
  return u, err
}

Stack change 2: Message queue peak shaving. Move time-consuming operations out of the request loop:

// After order creation, only send a message; inventory/notifications handled async by consumers
producer.Publish("order.created", OrderEvent{ID: order.ID})

Stack change 3: Distributed tracing. Connect OpenTelemetry, one traceID links the entire call path:

tp := oteltracesdk.NewTracerProvider()
otel.SetTracerProvider(tp)
// Logs, metrics, traces all share traceID; troubleshooting no longer requires searching a dozen systems

Stack change 4: Load testing to establish baseline. Use wrk or k6 to measure current QPS and P99:

wrk -t8 -c200 -d30s --latency http://localhost:8080/api/users

Acceptance criteria: have load test data, distributed tracing, and key interfaces with rate limiting and degradation. Achieve these three, and you deliver a system, not an interface.

4. Senior → Staff: From "Designed for Stability" to "Can Lead"

This jump changes not technology but the output shape: from delivering code to delivering decisions and standards.

Stack change 1: Write Architecture Decision Records (ADR). Solidify a technology choice so that people six months later know why:

# ADR-002: Order database uses sharding instead of vertical scaling

- Status: Accepted
- Background: Single table 800 million rows, write P99 exceeds 200ms
- Decision: Hash by user_id into 16 databases, 64 tables
- Consequences: Queries must include shard key; cross-shard aggregation goes to offline warehouse
- Failure condition: When data volume drops to below tens of millions, complexity can be reclaimed

Stack change 2: Define capacity and SLO. Use numbers to agree on how stable a system should be:

service: order-api
slo:
  availability: 99.95%
  latency_p99_ms: 300
error_budget: 0.05%   # If exceeded, freeze new features and repay stability debt first

Stack change 3: Define standards. Interface specs, error code tables, release processes, review checklists—write them so people can follow without asking you.

This level has no copy-paste code; the acceptance criterion is: your decisions are written down and executed by others, and the service can run on these methods even when you're away.

5. Each Level Delivers One Thing: A Work Checklist

Level This Week's Work Verifiable Output
Junior Write a user interface with parameter validation and unified response Has index, has ORM, one command starts the service locally
Mid Add Redis cache and Docker deployment to it Cache hit rate queryable, container starts with one click
Senior Add message queue, distributed tracing, and load test QPS/P99 data, key interfaces rate limited
Staff Write a sharding ADR and SLO definition Others can independently review and go live following the doc

Suggested practice: each week read one open source service architecture diagram (broaden perspective), each month add tests and indexes to old interfaces (strengthen quality), each quarter write one technical decision as an ADR and present it to the team (practice communication). Choose books by level; don't read cover to cover—junior reads language and database basics, mid reads refactoring and design patterns, senior reads distributed systems and performance, staff reads architecture and team collaboration.

6. Common Blockers

Phenomenon Root Cause How to Break Through
Interface works but nobody dares to modify No standards, no tests, raw SQL concatenation First unify response and parameter validation, then add tests
Adding cache introduces bugs Only wrote set, didn't think about consistency and expiration Define cache update strategy, add random jitter to expiration
Optimization only adds machines No load test data, don't know where the bottleneck is Use wrk to measure P99 first, then pinpoint the specific component
Technical proposals written but nobody reads Only wrote conclusions, no alternatives and failure conditions Write in ADR format, include trade-offs and rollback plans
Tech stack updated, but output unchanged Chasing new frameworks without binding to a problem For each stack change, first articulate which concrete problem it solves

7. Transition Signal

Moving from one level to the next isn't about years; it's about the tech stack and output in your hands changing: junior has runnable interfaces, mid has maintainable services, senior has load-bearing systems, staff has replicable architecture decisions. Each time you want to level up, first check the table in section 1—which column still uses the previous level's practices is the stack you need to change next.