GH-300 domain - 13% of the exam

Understand GitHub Copilot data and architecture

Understand GitHub Copilot data and architecture is 13% of the GH-300 exam. These are the objectives it covers, each with practice questions, with every answer explained.

The domain in numbers

36
Practice questions
3
Objectives
11
Easy
25
Medium

Where people go wrong

  • Confusing content exclusions with output filtering

    Content exclusions and duplication detection are swapped across these questions. Content exclusions act on the input side: named files or paths are not used as context for completions and chat. Duplication detection and the other proxy filters act on the output side: they inspect the candidate suggestion and suppress it before display. A wrong option that asks exclusions to compare suggestions with public code, or asks duplication detection to hide files from the prompt, reverses the two.

    See it in a sample question
  • Placing a step at the wrong point in the completion lifecycle

    The wrong answers move steps around the inline completion flow. Context is gathered first, the proxy assembles and forwards the prompt, the model generates the candidate, and the proxy then post-processes and filters it before the editor displays any survivor. The distractors show filtering after acceptance, a candidate displayed before filtering, an extension that generates the text, or a local model trained on keystrokes. A filtered candidate simply produces no ghost text.

    See it in a sample question
  • Swapping knowledge cutoff and context window

    Two separate model limits are exchanged in the wrong options. The knowledge cutoff concerns what the training data contained, so a framework released afterwards is unknown and the model improvises a confident answer that does not match the real interface. The context window concerns how much input fits in one request, so a long pasted file loses its early content and a large repository cannot be supplied whole. Neither limit explains the other symptom.

    See it in a sample question
  • Inventing training use for Business and Enterprise data

    The wrong answers invent a route by which Copilot Business and Copilot Enterprise data reaches model training: training on prompts but not suggestions, an opt-out by support ticket, training on accepted completions, sharing with other customers as training examples, or indefinite retention for training. The documented position for these tiers is simple. Prompts and suggestions are processed to return a completion and are not used to train the foundation models, and content exclusions play no part in it.

    See it in a sample question

Objectives in this domain

Sample questions from this domain

Free sampleUnderstand GitHub Copilot data and architecturemedium

An organisation administrator must stop a directory holding configuration secrets from ever being sent as context to GitHub Copilot, while still letting developers use Copilot on the rest of the repository. Which GitHub Copilot control should the administrator configure?

  • AModel Context Protocol, so the secrets directory is routed through an approved external server that decides when Copilot may read those files.
  • BDuplication detection, which compares each generated suggestion against public code and suppresses any match before it reaches the developer.
  • CContent exclusions, which prevent the specified files and paths from being used as context for completions and chat in the affected repositories. Correct
  • DCopilot Spaces, which package the secrets directory into a curated context bundle that developers attach when they want grounded answers.
Identify content exclusions as the control that stops named files or paths being used as Copilot context. Content exclusions are the administrative setting that names files or paths Copilot must not use as context for completions and chat, so they keep a secrets directory out of prompts while leaving the rest of the repository available, which neither Model Context Protocol, duplication detection, nor Copilot Spaces does.

Why A is wrong: Model Context Protocol connects Copilot to external tools and data sources; it does not block files from being used as context, so it cannot enforce the exclusion the administrator wants.

Why B is wrong: Duplication detection filters suggestions that match public code; it does not stop named local files being read as context, so it addresses output matching rather than input exclusion.

Why C is correct: Content exclusions let an administrator name files or paths that Copilot must not read as context for completions or chat, which precisely stops the secrets directory feeding suggestions while the rest of the repository stays usable.

Why D is wrong: Copilot Spaces curate context to include in chat, the opposite of excluding it; using a Space would expose the secrets rather than prevent them being read.

Free sampleUnderstand GitHub Copilot data and architecturemedium

A developer types in the editor and GitHub Copilot returns an inline completion. Tracing the request, the team wants to know where the prompt is assembled with surrounding context and sent to the model before any suggestion is returned. Which component performs that step in the suggestion lifecycle?

  • AThe editor extension renders the accepted suggestion and writes it into the file, which is the point at which the prompt is first assembled and dispatched to the model for completion.
  • BThe local language server indexes the whole repository and trains a per-project model, which then generates the completion entirely on the developer's machine without any network request.
  • CThe GitHub Copilot proxy receives the request, applies its filtering, forwards the assembled prompt to the model and post-processes the candidate before returning it to the editor. Correct
  • DThe audit log service records each keystroke and only after that recording succeeds is the prompt allowed to leave the client and travel toward the model for completion.
Identify the GitHub Copilot proxy as the component that filters requests, forwards prompts to the model and post-processes suggestions. In the suggestion lifecycle the client sends context to the GitHub Copilot proxy, which applies filtering, forwards the assembled prompt to the model and then post-processes the candidate suggestion before returning it, so the proxy is the step that bridges editor and model.

Why A is wrong: Rendering an accepted suggestion happens at the end of the lifecycle, so this confuses the final display step with the earlier point where the prompt is built and sent.

Why B is wrong: Copilot does not train a per-project model locally and completions involve a network call, so an offline local-training step is not part of the lifecycle.

Why C is correct: The proxy sits between the client and the model, so it is the component that filters the incoming request, passes the prompt to the model and post-processes the response before it reaches the editor.

Why D is wrong: Audit logging captures certain management events rather than gating individual keystrokes, so it is not the component that assembles and dispatches the prompt.

Free sampleUnderstand GitHub Copilot data and architectureeasy

A developer pastes a very long file into Copilot Chat and finds that details from the start of the file seem to be ignored in the reply. Which limitation of the underlying language model most directly explains why early content was dropped?

  • AThe knowledge cutoff date prevents the model from reading any file created after training finished.
  • BContent exclusions automatically trim the first half of any document before it reaches the model.
  • CCopilot Enterprise sends only the final paragraph of any prompt to conserve seat usage costs.
  • DThe model has a finite context window, so input beyond its size limit cannot all be considered at once. Correct
Recognise that a finite context window limits how much input an LLM can consider, causing overflow content to be ignored. Language models operate over a fixed maximum number of tokens known as the context window. When pasted input exceeds that limit, the earliest tokens fall outside what the model can attend to, so details from the start are effectively dropped.

Why A is wrong: The knowledge cutoff limits awareness of post-training events, not the reading of a file pasted at request time, so it does not explain dropped early content.

Why B is wrong: Content exclusions block specified repository files from being used as context and do not trim the first half of a pasted document, so this is incorrect.

Why C is wrong: Copilot Enterprise does not discard prompt content to save seat costs, so attributing the loss to a billing mechanism is factually wrong.

Why D is correct: A model processes only a bounded number of tokens at a time, so when the input exceeds the context window some of the earliest content is left out of the reply.

Free sampleUnderstand GitHub Copilot data and architecturemedium

A regulated team on Copilot Business asks how the prompts and suggestions that flow through the proxy during everyday coding are handled with respect to model training. Which statement accurately describes the default treatment for Copilot Business and Copilot Enterprise?

  • APrompts and suggestions are retained indefinitely and added to the public training corpus, so the team should expect their proprietary code to influence future model releases.
  • BPrompts and suggestions are shared with other customers as anonymised training examples, which is why duplication detection is needed to prevent that shared code reappearing.
  • CPrompts and suggestions are processed to return a completion but are not used to train the underlying models, so the team's proprietary code does not feed model training. Correct
  • DPrompts and suggestions are used to train the model only when the developer explicitly accepts a completion, with rejected suggestions excluded from any training set.
State that Copilot Business and Enterprise prompts and suggestions are not used to train the underlying models. Under Copilot Business and Copilot Enterprise the prompts sent through the proxy and the suggestions returned are processed to produce completions but are not used to train the underlying models, so proprietary code does not feed the training corpus.

Why A is wrong: Business and Enterprise prompts and suggestions are not used to train the models, so claiming indefinite retention for training contradicts the documented data handling.

Why B is wrong: Customer prompts and suggestions are not shared as training data, and duplication detection concerns public code, so this mischaracterises both controls.

Why C is correct: For Copilot Business and Enterprise the prompts and suggestions handled by the proxy are not used to train the models, which is the assurance the regulated team is seeking.

Why D is wrong: Acceptance does not trigger training on Business or Enterprise, so tying training to accepted completions still misstates the data handling guarantee.

Other domains in this exam

See also the GH-300 cert hub, the study guide, and the cheat sheet.

Examworthy is not affiliated with or endorsed by GitHub. Original, blueprint-aligned practice material only.