Shelf · Core Eng

Core Engineering

Git, testing, CI/CD, Docker, Linux and networking. The craft that separates builders from button-clickers.

11 chapters · 66 cards · 10 chapters written · #4 in your reading order

Difficulty
Priority
  1. Read the object graph, index and HEADMediumP1Know cold
  2. Choose a team branching strategyMediumP2Talk about it
  3. Rewrite local commits and transplant fixesMediumP3Know cold
  4. Resolve conflicts and recover lost workMediumP2Know cold
  5. Locate a regression with bisectMediumP3Talk about it
  6. Make PRs and hooks useful safeguardsEasyP2Talk about it
Difficulty
Priority
  1. Navigate files and permission boundariesEasyP2Know cold
  2. Explain processes, jobs and signalsMediumP2Know cold
  3. Build pipelines that preserve meaningMediumP2Know cold
  4. Run services, scheduled jobs and remote sessionsMediumP3Talk about it
  5. Diagnose CPU, disks, descriptors and syscallsMediumP3Talk about it
  6. Write a safe Bash automation scriptMediumP3Know cold
Difficulty
Priority
  1. HTTP wire contract: messages and observable outcomesMediumP1Know cold
  2. Apply REST semantics without promising exactly onceMediumP1Know cold
  3. Separate cookies, CORS and authorizationMediumP2Know cold
  4. Trace TLS and HTTP/1.1, HTTP/2 and HTTP/3HardP3Talk about it
  5. Receive authenticated, replay-aware webhooksMediumP2Know cold
  6. Debug a request with curl and timing evidenceEasyP2Know cold
Difficulty
Priority
  1. Authentication and authorization: sessions and JWTMediumP1Know cold
  2. Rotate refresh tokens and retire sessionsHardP3Talk about it
  3. Explain OAuth2 and OIDC flows end to endHardP2Talk about it
  4. Application threat boundaries: SQLi, SSRF and IDORMediumP1Know cold
  5. Protect passwords and manage secret exposureMediumP2Know cold
  6. Turn backend OWASP risks into negative testsMediumP2Know cold
Difficulty
Priority
  1. Testing strategy: unit, integration, contract and e2eMediumP2Talk about it
  2. Use red-green-refactor to test a behaviorMediumP3Know cold
  3. Choose test doubles, fixtures and data buildersMediumP2Know cold
  4. Test real infrastructure and service contractsMediumP3Talk about it
  5. Investigate flakiness and misleading coverageMediumP2Know cold
  6. Prove a data pipeline survives bad data and rerunsHardP2Know cold
Difficulty
Priority
  1. Container fundamentals: images, layers and runtimeMediumP2Know cold
  2. Build cache-friendly, repeatable DockerfilesMediumP2Know cold
  3. Choose multi-stage, slim or distroless imagesMediumP3Talk about it
  4. Make ENTRYPOINT, CMD and shutdown predictableMediumP2Know cold
  5. Persist data and connect local servicesMediumP2Know cold
  6. Diagnose and scan the shipped containerMediumP2Know cold
7

Kubernetes-lite

Planned
Difficulty
Priority
  1. Kubernetes fundamentals: pod, deployment, service and ingressMediumP3Talk about it
  2. Configure workloads without exposing secretsMediumP3Talk about it
  3. Distinguish probes, requests, limits and HPAHardP3Talk about it
  4. Inspect rollouts and choose rollback deliberatelyMediumP3Talk about it
  5. Read CrashLoopBackOff and know when k8s is overkillMediumP3Talk about it
  6. Rehearse 15 kubectl commands with context awarenessEasyP5Know it exists
Difficulty
Priority
  1. CI/CD and promotion: immutable artifacts to rollbackMediumP2Know cold
  2. Compare declarative Jenkins and GitHub Actions side by sideMediumP3Talk about it
  3. Turn test and security results into quality gatesMediumP2Know cold
  4. Put database migrations in a safe pipelineHardP2Talk about it
  5. Choose blue-green, canary and rollback signalsHardP3Talk about it
  6. Integrate often without granting CI excessive trustMediumP2Talk about it
Difficulty
Priority
  1. Observability model: logs, metrics, traces and eventsMediumP2Talk about it
  2. Add structured logs and Python OpenTelemetryMediumP3Talk about it
  3. Choose Prometheus metric types and useful dashboardsMediumP3Talk about it
  4. SLOs and incident signals: RED/USE and error budgetsHardP3Talk about it
  5. Respond to an incident and write a useful postmortemHardP2Talk about it
  6. Debug production without an attached debuggerHardP2Talk about it
Difficulty
Priority
  1. Configuration and secrets: precedence and feature flagsMediumP2Know cold
  2. Apply 12-factor principles to a real releaseMediumP3Talk about it
  3. Version releases and expire risky flagsMediumP3Talk about it
  4. Supply chain: SBOM, lockfiles, provenance and hygieneHardP3Talk about it
  5. Maintain dependencies and verify the released artifactMediumP3Talk about it
  6. Prepare runbooks and prove on-call readinessMediumP3Talk about it
Difficulty
Priority
  1. Senior engineering practice: review, ADRs, debugging and scopingMediumP2Talk about it
  2. Write a design doc and preserve the decision in an ADRMediumP3Talk about it
  3. Read an unfamiliar codebase and debug by hypothesisHardP2Know cold
  4. Estimate work, control scope and say no explicitlyMediumP2Talk about it
  5. Argue for tech debt with measured costsMediumP4Talk about it
  6. Communicate incidents and close ownership loopsMediumP2Talk about it