Repo Access: Temporary, Audited Work Samples Without Leaks
A CHRO-grade playbook for granting candidates controlled access to real code, capturing defensible evidence, and keeping hiring fast without turning your repos into an incident.

Repo access for work samples is not a favor. It is a controlled event you should be able to explain in an audit, a complaint, or a breach review.Back to all posts
The work-sample that turns into a repo incident
It is 9:20 AM. Your VP Engineering pings you: "Why is a candidate commenting on a private architecture doc in GitHub?" The hiring manager just shared a repo link in an email thread to speed up a work-sample test. The candidate asked smart questions, then cloned more than the exercise folder, found an internal roadmap, and opened an issue referencing a customer name in a test fixture. Now Legal is asking who authorized access, Security is asking what was exposed, and you are stuck explaining why a hiring workflow created an avoidable audit finding. By the end of this playbook, you will be able to run real-code work samples with temporary, audited repo access that is reversible, privacy-aware, and defensible when a candidate disputes the outcome.
Speed pressure: teams want higher signal than trivia tests, but shortcuts create uncontrolled access paths.
Cost pressure: an access mistake is not just cleanup time, it is reputational debt with candidates and internal stakeholders.
Risk pressure: IP leakage, customer data exposure, and inconsistent treatment across candidates creates legal and brand risk.
Why secure repo access is now a hiring integrity control
Real-code work samples can reduce "false signal" from AI-assisted answers because the candidate must navigate your conventions, tests, and constraints. The catch: the closer you get to production reality, the more you must treat access as a controlled event, not a casual link share. Fraud is part of this story too. Checkr reports that 31% of hiring managers say they have interviewed a candidate who later turned out to be using a false identity. Directionally, that implies identity and access controls belong earlier in the funnel, not just at offer. It does not prove that every remote role is affected equally, or that repo access is the root cause, but it is enough to justify guardrails that assume some percentage of attempts are adversarial.
Least privilege: candidates only see what they need to complete the task.
Time boxed: access expires automatically, no manual cleanup dependency.
Audited: every access is logged and attributable to a verified person.
Defensible: you can explain scoring, overrides, and access scope during a complaint or audit.
who owns it, what is automated, what is reviewed
This is where programs succeed or die. If repo access is "owned by whoever is in a hurry," you will get inconsistent candidate treatment and reviewer fatigue when incidents happen. Recommended ownership model: Recruiting Ops owns the workflow design, candidate comms templates, and the gating steps in the ATS. Security owns the access policy, logging requirements, and data minimization rules. Hiring Managers own the rubric and the technical evaluation, including code playback review. Automation vs manual review: Automate access provisioning (JIT), expiration, and event logging. Automate binding events to the requisition and candidate record. Manually review only exceptions: access failures, suspicious activity, or scoring disputes. Systems of truth: ATS is the system of record for stages and decisions. Your version control platform is the system of record for access events and code diffs. The verification service is the system of record for identity proofing outcomes and any step-up checks.
ATS stage change triggers provisioning (not a Slack request).
Candidate completes work sample async, submits via PR or patch.
Hiring manager reviews with a standardized rubric and code playback notes.
Ops revokes access automatically, stores an evidence pack pointer in the ATS.
a step-by-step playbook for temporary, audited repo access
Decide the access model by role risk and exercise type. If you can, use a sanitized "work-sample repo" that mirrors patterns from production but contains no customer data, secrets, or non-public roadmap. If you must use a real repo, create a dedicated exercise directory and a scoped view or sparse checkout instructions, but assume candidates can still discover more unless permissions are truly constrained.
Build an "exercise harness" that produces reviewable evidence. Your goal is not just code output, it is review ergonomics. Require tests, require a short design note, and capture how they approached tradeoffs. Use code playback (recorded terminal or IDE events, or structured commit history) to resolve disputes like "I wrote that, but my environment broke."
Provision access Just In Time with expiration and audit logging. Access should be granted only after identity is verified and the candidate is scheduled for the work sample window. Provision to a candidate-specific identity, not a shared account. Expire access automatically at the end of the window, and log all access events.
Lock down the data blast radius. Remove secrets from the repo and enforce secret scanning. Strip fixtures that contain customer identifiers. Disable forks for the exercise repo, or enforce private forks with retention rules. Ensure candidate accounts cannot invite collaborators or create additional tokens.
Standardize scoring and exception handling. Use one rubric per role family. Define what triggers a manual security review: abnormal clone volume, repeated auth failures, access from unexpected geographies relative to the verified identity context, or evidence of proxy activity. Define a candidate appeal path that replays evidence rather than re-litigating "vibes."
Package an Evidence Pack for every decision. At minimum: verification outcome, access grant and revoke timestamps, repo events, submission artifact (PR link or patch hash), rubric scorecard, reviewer notes, and any overrides. This protects your team when a candidate challenges the decision or alleges unfair treatment.
Pre-approved access templates per role, so managers do not improvise permissions.
Idempotent webhooks for provisioning so retries do not create duplicate invites.
Short-lived access tokens with forced rotation and no long-lived PATs.
A single "exception queue" that prevents ad hoc escalations across Slack threads.
JIT repo access policy (candidate work sample)
Use this as a starting point for a policy your Recruiting Ops and Security teams can co-own. It is written to be implementable: it defines scope, TTL, logging, and what gets attached to an Evidence Pack in the ATS.
Store it in an internal "Hiring Controls" repo and require PR review from Recruiting Ops + Security.
Map the fields to your GitHub or GitLab automation and your ATS custom fields.
Treat policy changes like any other control: versioned, approved, and auditable.
Anti-patterns that make fraud worse
These three patterns increase both fraud risk and candidate complaints because they are inconsistent and hard to audit.
Sharing a single "candidate" login or token across applicants to save time.
Granting broad org access "just for today" with manual revocation later.
Accepting submissions via email attachments or pastebins instead of controlled PRs or patches.
Dispute resolution: how you stay fair and consistent
CHRO anxiety is not only "did we get hacked," it is "will this look arbitrary." A work-sample program becomes reputationally expensive when candidates claim inconsistent evaluation or when internal teams cannot explain a decision six weeks later. A defensible dispute flow is lightweight: If a candidate appeals, you replay evidence. You do not re-run the entire process. Review the PR or patch, the rubric, and the access log. If there is ambiguity (for example, tooling failed), allow a bounded retake with a new access window and a recorded environment check. Capture the outcome as an addendum to the Evidence Pack so future audits see the full story.
One rubric per role level with anchored scoring examples.
A documented retake policy for environment failures (not performance).
A rule that reviewers must cite code evidence, not personal style preferences.
Where IntegrityLens fits
IntegrityLens AI is the first hiring pipeline that combines a full Applicant Tracking System with advanced biometric identity verification, AI screening, and technical assessments so you stop juggling tools and keep decisions defensible. For secure work samples, IntegrityLens keeps the workflow in one place: TA leaders and recruiting ops teams orchestrate stages in the ATS, CISOs get auditable verification and fraud signals, and hiring managers get review-ready submissions. Key fit points for repo-access work samples: You can verify identity in under three minutes before access is granted, run async AI screening interviews 24/7 to reduce scheduling drag, and standardize technical assessments (40+ languages) alongside real-code exercises, with Evidence Packs tying it together.
Fewer tool handoffs, fewer gaps in audit trails.
Cleaner exception handling with consistent evidence capture.
A candidate experience that feels intentional, not suspicious.
Outcome proof: what improves when repo access becomes a controlled workflow
When teams move from ad hoc repo sharing to time-boxed, logged access with standardized submissions, the improvement is mostly in controllability and dispute handling. You spend less time in war rooms reconstructing who granted what, and more time hiring. Qualitative outcomes you should expect (not a numeric guarantee): fewer last-minute escalations to Security for "mystery access," faster reviewer alignment because every submission arrives in the same format, and better candidate trust because the process is consistent and reversible.
Data minimization: no customer data in exercises, no secrets in repos, and clear retention limits for logs.
Access controls: least privilege, MFA/SSO, and automatic expiration.
Appeal flow: documented retake and dispute resolution with evidence, not ad hoc exceptions.
Sources
- Checkr, "Hiring Hoax" Manager Survey (2025): https://checkr.com/resources/articles/hiring-hoax-manager-survey-2025
Related Resources
Key takeaways
- Design repo access like a production change: time-boxed, scoped, logged, and reversible.
- Separate evaluation signal (code changes + playback + rationale) from raw repo exposure (secrets, customer data, internal roadmaps).
- Make ownership explicit: Recruiting Ops runs the workflow, Security sets guardrails, Hiring Managers evaluate, and the ATS remains system of record.
- Use evidence packs to resolve disputes: what the candidate touched, what was submitted, and how it was reviewed.
A policy template that defines when candidates can access a work-sample repository, how long access lasts, what permissions are allowed, what is logged, and what gets attached to the candidate Evidence Pack in the ATS.
Designed to reduce funnel leakage from ad hoc access and to minimize reviewer fatigue during disputes.
policyVersion: "2025-12-14"
policyName: "candidate-work-sample-jit-repo-access"
owner:
primary: "recruiting-ops"
securityApproverGroup: "security-grc"
scope:
repoStrategy:
preferred: "sanitized-work-sample-repo"
allowRealRepo: false
allowedRepos:
- "github.com/acme/work-samples"
prohibitedContent:
- "customer-data"
- "production-secrets"
- "non-public-roadmap"
provisioning:
trigger:
systemOfRecord: "ATS"
event: "stage_changed"
stageName: "Work Sample - Repo Access"
prerequisites:
- name: "identity-verified"
source: "IntegrityLens"
required: true
- name: "candidate-nda-on-file"
source: "ATS"
required: true
accessModel:
method: "JIT-invite"
identity:
type: "candidate-specific"
sharedAccountsAllowed: false
permissions:
role: "read"
canFork: false
canCreateIssues: true
canInviteCollaborators: false
ttlMinutes: 240
autoRevoke:
enabled: true
revokeOn:
- "ttl_expired"
- "candidate-withdrawn"
- "stage_changed_out"
loggingAndEvidence:
requiredLogs:
- "invite_sent"
- "invite_accepted"
- "clone_or_checkout"
- "auth_failures"
- "pull_request_created"
- "access_revoked"
evidencePack:
attachToATS:
enabled: true
fields:
- "verification_result_id"
- "repo_access_grant_timestamp"
- "repo_access_revoke_timestamp"
- "repo_event_log_uri"
- "submission_artifact_uri" # PR link or patch hash
- "rubric_scorecard_uri"
- "reviewer_code_playback_notes"
exceptions:
manualReviewQueue: "hiring-integrity-exceptions"
triggers:
- "access_attempt_after_revoke"
- "multiple_auth_failures_over_threshold"
- "unexpected_geo_relative_to_verified_context"
- "large_volume_checkout_detected"
retention:
accessLogsDays: 90
evidencePackDays: 365
biometrics: "Zero-Retention Biometrics"
securityBaseline:
encryption: "256-bit AES"
infrastructure: "Google Cloud SOC 2 Type II audited infrastructure; ISO 27001-certified infrastructure"
Outcome proof: What changes
Before
Hiring managers shared repo links and access ad hoc. Access revocation depended on memory. Submissions arrived via mixed channels (email, zip files, PRs). Disputes required reconstructing timelines from scattered systems.
After
Repo access became JIT, time-boxed, and logged, triggered by ATS stage changes after identity verification. Submissions standardized to PR or patch with code playback notes. Evidence Packs made disputes resolvable without re-running the full process.
Implementation checklist
- Create a sanitized work-sample repo or scoped read-only view (no secrets, no customer data, no roadmaps).
- Grant access via expiring identity (JIT) with least privilege and forced MFA/SSO.
- Log every access event and bind it to a candidate + requisition in the ATS.
- Require submissions through controlled channels (PR or patch) with code playback notes.
- Revoke access automatically and retain a minimal audit trail for dispute resolution.
Questions we hear from teams
- Do we need to give candidates access to our real production repo to get strong signal?
- Usually no. You can get most of the signal from a sanitized repo that mirrors your patterns: tests, conventions, and dependency boundaries. If a real repo is unavoidable, constrain it to a dedicated exercise repo or a tightly scoped project with explicit minimization and logging.
- How do we keep cycle time fast without turning Security into a gatekeeper?
- Pre-approve access templates and automate provisioning and revocation via ATS-driven triggers. Security reviews only exceptions based on defined triggers, not every candidate.
- What is the minimum evidence we should retain for disputes?
- Verification outcome reference, access grant and revoke timestamps, repo event logs pointer, submission artifact (PR or patch hash), rubric scorecard, and reviewer notes. Keep it consistent so your appeal flow is repeatable.
Ready to secure your hiring pipeline?
Let IntegrityLens help you verify identity, stop proxy interviews, and standardize screening from first touch to final offer.
Watch IntegrityLens in action
See how IntegrityLens verifies identity, detects proxy interviewing, and standardizes screening with AI interviews and coding assessments.
