> ## Documentation Index
> Fetch the complete documentation index at: https://docs.pebchip.top/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Get Started with the FlightAware Knowledge Base

> Learn how to navigate the FlightAware technical knowledge base to accelerate your learning across databases, backend engineering, and computer science.

This guide walks you through the fastest way to get value from this knowledge base. Whether you are preparing for a backend engineering interview, deepening your understanding of a specific system, or building a habit of structured technical note-taking, the steps below show you how to orient yourself and start moving.

<Steps>
  <Step title="Choose your learning path">
    Pick the path that matches your current focus. The tabs below give you a recommended reading order for four common engineering profiles. You do not need to read everything — go deep on what matters most right now and return to other areas as you need them.
  </Step>

  <Step title="Use the note template">
    As you work through topics, use the [lightweight technical note template](/note-template) to record what you learn. The template structures your understanding into seven sections: background, phenomenon, root cause analysis, solution comparison, practical advice, references, and a one-line summary. Writing notes this way makes the knowledge stick.
  </Step>

  <Step title="Go deep on a topic">
    Each page covers one focused concept. Read the background to understand why the topic matters, study the principle analysis to understand how it works, and check solution comparisons to understand the trade-offs. The practical advice section gives you rules of thumb you can apply immediately.
  </Step>

  <Step title="Apply the interview prep">
    Once you have built depth on a topic, practice explaining it. Review the [Interview Guide](/reference/interview-guide), the [Networking Q\&A](/reference/networking-bagu), and the [Database Q\&A](/reference/database-bagu) to see how topics appear in practice. The goal is not just to know the answer, but to explain it clearly and connect it to real experience.
  </Step>
</Steps>

## Learning Paths

<Tabs>
  <Tab title="Database Engineer">
    Start with the concepts most likely to come up in interviews and production incidents, then build toward advanced internals.

    1. **[Redis](/databases/redis)** — Understand cache avalanche, breakdown, and penetration. Learn the five data types and when to use each.
    2. **[MySQL](/databases/mysql)** — Learn how B+ tree indexes work, read `EXPLAIN` output, and understand MVCC and transaction isolation.
    3. **[Kafka](/databases/kafka)** — Producer delivery guarantees, consumer group offset management, and Kafka vs RabbitMQ tradeoffs.
    4. **[Elasticsearch](/databases/elasticsearch)** — Inverted index internals, query DSL, and when to use ES instead of MySQL.
    5. **[Distributed Systems](/design/distributed-systems)** — Distributed locks, CAP theorem, and reliability patterns in practice.
    6. **[Database Interview Q\&A](/reference/database-bagu)** — Review common interview questions with structured answers.
  </Tab>

  <Tab title="Backend/Go Developer">
    Build a solid understanding of Go's runtime, then move into distributed system patterns.

    1. **[Go](/backend/go)** — GMP scheduler, goroutines and channels, garbage collection, and generics.
    2. **[Design Patterns](/design/design-patterns)** — Factory, Observer, Strategy, and the other 20 GoF patterns with Go examples.
    3. **[Microservices](/backend/microservices)** — gRPC, etcd service discovery, CAP theorem, and distributed transactions.
    4. **[Distributed Systems](/design/distributed-systems)** — Raft consensus, distributed locks, idempotency, and reliability patterns.
    5. **[Docker](/backend/docker)** — Containers, Dockerfiles, Compose, and networking.
    6. **[System Design](/reference/system-design)** — Framework and common system design patterns for interviews.
  </Tab>

  <Tab title="Java Developer">
    Start with JVM fundamentals, then build toward the Spring ecosystem and microservices architecture.

    1. **[Java](/backend/java)** — JVM internals, class loading, multithreading, and Java 8+ features.
    2. **[Spring Boot & MyBatis-Plus](/backend/java)** — Auto-configuration, dependency injection, and common ORM patterns.
    3. **[Microservices](/backend/microservices)** — SpringCloud stack, gRPC, etcd, and distributed transactions.
    4. **[DDD](/design/ddd)** — Domain-driven design concepts applied to large Spring Cloud microservices codebases.
    5. **[Design Patterns](/design/design-patterns)** — All 23 GoF patterns with Java code examples.
    6. **[System Design](/reference/system-design)** — Scalability patterns and how to approach system design interviews.
  </Tab>

  <Tab title="Systems & Algorithms">
    Build the computer science foundations most tested in technical interviews, then practice applying them.

    1. **[Networking](/cs/networking)** — TCP three-way handshake, HTTP versions, WebSocket, SSL/TLS, and security.
    2. **[Operating Systems](/cs/operating-systems)** — Virtual memory, CPU scheduling, I/O multiplexing (epoll), and synchronization.
    3. **[Data Structures](/cs/data-structures)** — Trees, heaps, hash tables, and graphs with Big-O analysis.
    4. **[Algorithms](/cs/algorithms)** — Dynamic programming patterns, graph algorithms, greedy, and math algorithms with C++ code.
    5. **[Networking Q\&A](/reference/networking-bagu)** — Common interview questions on TCP, HTTP, and security.
    6. **[Interview Guide](/reference/interview-guide)** — Study plan and strategy for technical interviews.
  </Tab>
</Tabs>