Source Control Operating Model Using GitHub | Learn

Learn / Source control

HA-SCOM-001 · Responsibilities and profiles

Source Control Operating Model Using GitHub

By Henok Ahmed · Version 1.0.0 · 28 October 2026

A practical model for freelance website work and growing delivery teams

By Henok Ahmed

Version 1.0.0
Document HA-SCOM-001 · First prepared 25 October 2026 · Edited 28 October 2026
Status: Published with author approval on 28 October 2026.
License: CC BY 4.0 for original educational text, tables, prompts, checklists and text templates, subject to stated exclusions.

Companions: Practical Guide, HA-SCOM-002, and Template Pack, HA-SCOM-003. Use all three at Version 1.0.0.

Start with the work you want to deliver

You have a computer science, information technology or related background. You understand some computing concepts but may never have delivered a website to a paying client. You want to become a freelancer or establish a small website business serving individuals and small organizations.

You may work from Debre Markos, Hawassa, Dessie or another location outside Addis Ababa. Plan around the equipment, connectivity, power, language and support actually available to you. Geography does not determine competence; demonstrated work and reliable delivery matter. Do not assume that every learner has the same access or constraints.

For a first project, keep the website bounded: Home, About, Services and Contact, with truthful content and an agreed email/phone contact route. More pages, a contact form or other integrations need their own scope and checks. Payments, accounts, bookings and restricted uploads are not beginner extensions simply because WordPress offers plugins for them.

GitHub can help you explain what changed, preserve agreed source, review work and identify what you delivered. It does not find clients, establish earnings, host WordPress automatically or replace operational backups. Codex can accelerate preparation and implementation; you must still understand the result and verify it.

Read the WordPress foundation guide for client preparation and delivery concepts. Use the 24 Working Hours runbook and prompt deck for building a first site. Its 24 hours is a planning allowance, not a tested guarantee. This source-control family explains how to keep that work traceable and recoverable; it sets no completion-time promise.

How the three documents work together

Document Your question What it supplies
Operating Model What responsibilities and controls should this project adopt? Common rules and two operating profiles
Practical Guide What do I do on my computer, and what can Codex help me do? A first-project sequence, prompts, errors and worked examples
Template Pack What information should I record? A small-project record route and reusable T01–T14 templates

The model defines requirements for projects that explicitly adopt it. The guide illustrates them; an example cannot waive a requirement. Templates record work and decisions; filling a form does not perform a test or grant approval.

Must means required under the adopted profile. Should means recommended, with reasons recorded for adaptation. May means optional. These words do not authorize this assistant, a learner or a project to access systems, spend money, publish client material or deploy a website.

The primary learning path uses Foundation. Controlled is an escalation profile for consequential work, not a claim that reading this family qualifies a beginner to deliver portals or transaction systems.

1 Understand the minimum vocabulary

Term Plain meaning Website example
Git Version-control software that records source history History of your page text and styles
GitHub A service for hosting repositories and coordinating changes A project repository with issues and pull requests
Repository Project files plus their version history Approved source for one client's site
Working copy Files currently being edited on your computer Your selected website folder
Staging area (Git) The selected changes prepared for the next commit Inspect exactly which files and lines will be recorded
Staging environment (website) A separate test installation Check a candidate before changing production
Commit A recorded source snapshot with an explanation “Clarify service deliverables”
Commit SHA The identifier of that commit Record the full actual value in delivery evidence
Branch A named line of work A branch for correcting the Contact page
Issue A record of work or a problem Client requests clearer service wording
Pull request (PR) A proposed change presented for review Compare that branch with main
Diff The actual lines that changed A phone number changed in one page
Merge Incorporating a branch's change into another branch Accepted source joins main
Push / fetch / pull Send local commits / retrieve remote information / retrieve and integrate Reconnect after working locally
CI / check An automated test or validation run Check local section links or build output
Artifact Output prepared for review or deployment A versioned set of WordPress content blocks
Candidate The exact proposed delivery under review The tested page content at rc.1
Release A named version linked to source, artifacts, notes and evidence The accepted first website increment
Deployment Applying the approved content/configuration to a destination Saving the accepted blocks into the intended WordPress pages
Public launch Owner authorization to make the approved result available to its intended audience Client approves the public site
Drift Actual website or files differ from recorded source Client edited a service paragraph directly in WordPress
Recovery Restoring the required working service and data Reapply prior content, or restore database/files when needed

GitHub's Hello World tutorial demonstrates repository, branch, commit and PR work in the browser without requiring command-line knowledge. The Practical Guide uses that as a preparation exercise, then applies the workflow to website source.

A commit can remain local until sent to GitHub. A push does not publish WordPress pages. A merge does not prove that the live website changed. A release is not proof that public launch was authorized.

2 Keep WordPress and GitHub connected deliberately

Most WordPress editing changes database content. Git cannot see those changes merely because you created a repository. The project must name the authoritative editing location and explain how accepted work moves between files and WordPress.

Choose an approach you can explain and maintain:

Approach What you track How it reaches or returns from WordPress
Native block editor or page builder Appropriate saved block text, supported exports, asset references and editing instructions Document the supported export/import or manual editing procedure; record items the export omits
Authored HTML/CSS blocks Reviewed text blocks and scoped styles Save them into the verified page/editor using the authorized route; reopen and compare saved output
Custom theme or plugin Actual source, dependency records and build instructions Use an operator-approved installation/deployment process; this needs additional development competence

Do not flatten a builder layout into HTML and call it an equivalent editable backup. A page ID from one WordPress installation may identify a different page elsewhere. Track URLs and environment-specific IDs together.

Source boundary

Normally track approved page text, authored styles, approved public assets where appropriate, safe configuration examples, build/editing instructions, validation evidence and decisions. Keep real passwords, tokens, private enquiries, database dumps, private client records and unrelated personal files out.

Name an owner for the database, uploaded media, plugins/themes, hosting, domain, email delivery and other external services. Record backup and restoration references in an appropriate location. WordPress describes database and files as separate parts of its backup arrangements. A repository containing page exports alone cannot restore them all. See WordPress Backups.

A private repository restricts repository access; it does not restrict the website. A noindex setting concerns indexing and is not an access restriction.

3 Choose the operating profile

Select by consequences and recovery needs, not page count, business size or how confident the AI sounds.

Area Foundation Controlled
Fit Bounded consequences and understood recovery Material service/data consequences or coordination complexity
Typical context A modest informational/marketing site with suitable obligations Restricted records, consequential integrations or stronger contractual controls
Review Recorded review; solo self-review disclosed Reviewer independent of the author
Production approval Named owner/delegate with actual authority Production approver distinct from the author
Test setting A safe preview/test arrangement appropriate to impact Separate staging with suitable isolation and representative configuration
Enforcement Verify available settings; record gaps and compensation Verify required PR/check/review enforcement on critical branches
Recovery A documented, verified method proportionate to impact Recovery exercised against owner-approved objectives
Branches Usually short-lived feature/fix branches into main The same can work; add integration/stabilization branches only when justified

Both profiles require linked changes, meaningful checks, identifiable source/releases, accountable decisions, protected secrets, visible gaps and practical recovery.

When to select Controlled

Use T02 to assess failure effects, data and privileges, recovery difficulty, dependencies, contributor coordination and obligations. Select Controlled when any of these materially require stronger assurance. Ordinary approved public contact information alone does not force Controlled. Sensitive records, difficult migrations or consequential account/payment behavior can change the assessment substantially.

Missing money, reviewers or tools does not make a consequential project suitable for Foundation. Investigate, narrow the work by agreement, arrange competent support or decline the unsupported scope. Do not sell delivery capability you cannot demonstrate.

Complete T01/T02 before routine changes. Reassess before launch and when scope, data, dependencies, participants or obligations change. Record why a profile is suitable; lowering it requires evidence and owner approval.

4 Assign people to the decisions

Role Responsibility in a freelance website project
Owner Usually the client: accepts scope, claims, public contacts and launch
Maintainer Keeps repository/workflow usable and manages approved access
Contributor Prepares the change and its evidence; often the freelancer
Reviewer Examines the diff, behavior and adequacy of checks
Release coordinator Identifies the exact candidate and delivery package
Operator Applies approved changes and manages restoration

Foundation may combine roles. A solo freelancer may self-review, but must disclose it. Being the implementer does not automatically make you the client's approval authority. Codex can assist with review; it is not a second accountable human or an independent approver.

Controlled requires independent change review and a production approver other than the author. One competent independent person may perform both. Record names, authority, competence, deputies and any role combinations in T01. Operators need not be independent of authors unless the project requires it.

Use attributable accounts with minimum necessary access. The client should control business-critical services under an agreed ownership arrangement. Do not make the client dependent on your personal password. Record access reviews at onboarding, role changes, departure and the interval chosen in T01. Handover includes the agreed repository/service ownership and access arrangements, with credentials transferred through approved secure channels rather than written into Git.

5 Establish a baseline you can trust

Before import, inspect the actual folder, repository and website. Preserve unknown work. An existing public website may differ from an old local export. State where the baseline came from, when it was captured, what it includes and what it omits.

For a new practice project, a minimal repository can begin with README, content and docs. Add CONTRIBUTING, SECURITY, CHANGELOG, ignore rules, appropriate templates and build/check instructions as those responsibilities are established before routine client delivery. Do not create empty folders and claim a working delivery system.

README.md                   purpose, scope, editing and verification instructions
CONTRIBUTING.md             branch/PR route and decision responsibilities
SECURITY.md                 private reporting route; no secret values
CHANGELOG.md                actual changes and release references
.gitignore                  reviewed exclusions for this project
content/                    approved authored content or supported exports
assets/                     only authorized assets needed by the source
config/                     safe examples; no live credentials
scripts/                    actual utilities with usage and limits
tests/                     meaningful tests, when present
docs/                      decisions, acceptance, handover and evidence references
.github/                    selected issue/PR templates and reviewed workflows

Use T03 to record actual settings, not intended settings. Review the baseline through a setup PR. The initial repository may need an initial README commit on main so a setup branch can exist; record that bootstrap explicitly. This does not create a general permission to bypass routine review.

An ignore rule prevents appropriate untracked files from being added automatically; it does not erase earlier commits or make excluded files secret. Inspect what will be committed. See GitHub's ignoring-files guidance.

6 Use one change cycle repeatedly

  1. Define — T04. State the problem, useful result, scope/exclusions, acceptance criteria, owner, impact and checks. Link to the client brief.
  2. Implement. Work on a short-lived branch from the declared integration point. Keep the change focused and explain commits in terms of the result.
  3. Validate — T06. Check actual failure modes. For a marketing site these usually include factual accuracy, links, saved content, mobile/keyboard behavior and the agreed contact route.
  4. Review — T05. Read the diff and inspect the result. Record actual checks, evidence, omitted checks, findings and self-review/independent-review status.
  5. Accept and integrate. Resolve material findings or an authorized bounded exception, then merge under the declared strategy. Close only criteria actually satisfied.
  6. Authorize and deliver — T07/T08. Identify candidate, artifact and destination, obtain the required decisions, deploy and verify what actually runs.
  7. Learn — T11/T12. Classify feedback and improve the next change.

A source issue may close when its defined source criteria are met. If it includes live-delivery criteria, a merge alone does not complete it. Leave deployment work visibly open or use a linked delivery record.

Use main as the normal reviewed baseline. Develop/release branches are optional. Avoid direct routine changes to critical branches, force pushes to shared history and changing published version identities. Keep parallel tasks separate when you can explain how they will be integrated.

7 Make approval understandable to the client

A decision gate is a point where a named person decides whether the next action may proceed. It is not necessarily a separate meeting or form.

Gate Evidence Accountable decision
Adoption Scope, profile, responsibilities and known gaps Owner
Change acceptance Diff, criteria, checks and review Maintainer; independent review in Controlled
Release readiness Exact candidate/artifact, feedback and remaining limits Release coordinator and owner/delegate
Deployment authorization Exact artifact/target, operator, backup and recovery Owner/delegate; independent approver in Controlled
Public launch Audience access, claims, contact journey and accepted limits Owner
Learning review Actual results and assigned improvements Owner and participants

Foundation may combine decisions in one T07 record if each is explicit. Translate technical identity into an understandable review package: named preview, candidate version, changed pages, intended destination, contact route and known limits. Keep the full source identity in the linked technical record.

Silence, a green check or “looks nice” does not establish deployment authority. Approval applies to the named source/artifact/target and conditions. Changed claims, source or material assumptions reopen affected decisions. Conditional approval does not permit unmet conditions to be ignored. Release readiness can precede a stable tag if exact accepted source/artifact identity is preserved. Learning review is not a barrier to already authorized urgent restoration.

8 Use checks you can explain

Automate repeatable checks that address a real failure, such as broken local links or malformed build output. Add behavior tests when custom code justifies them. Do not create superficial tests merely to make a dashboard green. Record manual checks where automation cannot establish the result.

CI means configured automated checks; it is not a requirement to learn every automation feature before making a first practice change. A manually checked baseline must say which checks were manual and whether any adopted requirement remains unmet.

Configure required PR/check/review controls where available, and verify behavior with a harmless test change. A saved ruleset or ownership file alone is not evidence of enforcement. GitHub features depend on the repository/account arrangement; check the current service and record the result in T03. Do not expose a private client repository merely to obtain an available feature. See GitHub rulesets.

Build exact source using declared tools and dependencies. Retain the evidence/artifacts needed for the agreed support and recovery period. Keep validation permissions minimal and deployment credentials separate; review external workflow code and use reviewed full action commits when adopting third-party actions. Treat outside contributions and inputs as untrusted. Check current GitHub secure-use guidance before implementing workflows.

Green CI proves only that its configured checks passed. A valid content file does not prove the saved WordPress page is correct. A form's success message does not prove an enquiry arrived. A screenshot is not comprehensive accessibility evidence.

9 Identify versions and the running site

Agree a website/content convention. For this family, the example progression is v0.1.0-dev.1 → v0.1.0-rc.1 → v0.1.0; a correction can be v0.1.1 and the next increment v0.2.0-dev.1. These are teaching conventions, not universal compatibility promises. Software with a compatibility contract should define an appropriate versioning policy separately.

Mark development/candidate GitHub releases as prereleases when using that mechanism. Store the full source SHA and artifact checksum where applicable in T06. A checksum identifies a particular file; it does not prove quality. Changed candidates get new identities and affected checks. Do not move published tags.

Record deployment separately in T08: exact destination, expected current state, source/artifact, configuration, operator, time, result and post-deployment checks. Compare drift before overwriting. Record rollback triggers and authority first. An urgent WordPress edit must be captured and reconciled through the repository workflow before the next release.

A Git revert changes source history through a new commit. It does not automatically restore WordPress or undo database changes. Foundation verifies the applicable recovery method before affected production changes. Controlled agrees acceptable recovery time/data loss and exercises recovery against those objectives using T09.

10 Work reliably with Codex and limited connectivity

Ask Codex to inspect actual capability before work: selected folder, repository, branch, remote, available Git/GitHub tools and WordPress access. A signed-in browser does not imply local Git or server access. If a tool is unavailable, it should prepare safe local work and give a precise manual action with an expected result. Never treat an invented repository URL or attempted push as success.

Use bounded prompts stating the goal, relevant context, constraints and completion check. This follows the structure of official prompting guidance; the prompts in the companion guide are original teaching recommendations, not tested automation scripts. Actual permissions still apply.

During an outage, locally available files and installed Git can support offline preparation and commits. GitHub synchronization and a hosted AI session need their relevant connections. Do not promise offline Codex availability. Before publishing or integrating after reconnection, inspect remote changes and reconcile them; do not force an upload over unknown work.

End each session with the last verified source/site state, local unpushed work, pending decisions and next action. Keep that record in a suitable project location; it should allow a new session to resume without relying on chat memory. Store source and recovery material in the agreed additional locations. A single laptop and unpushed commits remain a loss risk.

11 Make the process useful to a small business

Explain source control to a client through benefits you can demonstrate: an agreed baseline, a readable change record, evidence of checks and a handover another maintainer can understand. Do not promise that GitHub eliminates defects or makes support free.

T04 should distinguish a defect against agreed criteria from a new request. Clarifying the promised service wording can be an included correction; adding online booking may be new discovery and pricing. Agree revisions, maintenance, source/asset ownership, licensing, third-party costs and acceptance in the client brief. This model does not set local market prices or replace that agreement.

At handover identify the operating version, routine editing route, repository/service owners, renewals, support boundaries, recovery contact and outstanding work. Confirm the owner can perform the agreed routine edit. Capture resulting WordPress drift so the final source remains meaningful. Portfolio reuse requires the relevant permission; one client's private material is not a reusable template.

12 Handle gaps and emergencies truthfully

T10 records an unmet control, consequences, compensation, authority, permitted actions, expiry and corrective owner. Recording a gap does not satisfy the control. Controlled work cannot pass affected gates with material gaps unless an authorized time-limited arrangement actually addresses the risk and obligations permit it. Nonwaivable obligations remain binding.

Declare an emergency route in T01. Start urgent fixes from the deployed baseline, make the smallest justified change, run essential checks and use available required review or authorized emergency decisions. Record deferrals with owners/deadlines and reconcile development after restoration. Existing rollback authorization can permit recovery without waiting for a new feature decision.

If a secret enters Git history, stop spreading it, arrange revocation/rotation and assess exposed history/artifacts through the authorized route. Deleting the current line or adding an ignore rule is insufficient. Keep incident details appropriately restricted; do not paste the secret into a support prompt.

13 Choose the records without multiplying paperwork

Foundation may combine records in one project log or PR, provided every applicable field/decision remains traceable. The Template Pack supplies a combined route; it does not remove controls.

When Records to complete or update
Adopt the project T01 + T02; T03 for settings/access
Make a change T04 + T05
Prepare and deliver a candidate T06 + T07 + T08; T09 recovery evidence
A gap, incident or emergency occurs T10 and affected delivery records
Feedback or learning occurs T11 + T12
Propose a change to this official model T13
Approve publication of this document family T14; separate from any client's website

Do not complete T13/T14 for every service-page edit. Use actual results, stable references and appropriate access rather than copying sensitive logs into every record.

14 Evidence, stewardship and editions

The initial henokahmed.com MVP-01 work supplied real examples of baseline capture, source organization, checks, PRs and development-release planning. Historical setup limits included unavailable branch enforcement under the account arrangement observed, incomplete separate staging/full host recovery, and unverified target-server importer behavior. Later educational publications used explicit author approval, dedicated PRs and live content checks; those limited observations are not a comprehensive operating audit or a timed learner study.

The Practical Guide's people, clients, websites, results and recovery figures are fictional. Its stronger recovery arrangements are teaching choices, not retrospective claims about the initial project.

Use T12 to review actual rework, escaped defects, deployment failures, recovery and unclear decisions. Define measurements before claiming improvement. Propose model changes with evidence through T13. Henok Ahmed is the proposed steward; official edition changes require recorded approval and compatible companion updates. Patch editions clarify, minor editions add compatible guidance and major editions alter required responsibilities/process. Project adaptations name their owner and parent edition; they do not change the official model.

15 License and publication record

Copyright © 2026 Henok Ahmed. The original educational text, tables, prompts, checklists and text templates in this publication family are licensed under Creative Commons Attribution 4.0 International (CC BY 4.0). Give appropriate credit, link to the license and indicate changes, without implying endorsement. This grant excludes underlying project software, private files, third-party materials, trademarks, credentials and personal data. Those materials retain their respective rights.

Henok Ahmed approved HA-SCOM-001, HA-SCOM-002 and HA-SCOM-003, edition 1.0.0-draft.4, for publication as Version 1.0.0 on 28 October 2026. This approval does not authorize client deployment or the overall website’s stable public launch. This model is not endorsed or certified by GitHub, OpenAI or WordPress.

Source: https://henokahmed.com/source-control-model/

References and editorial record

Primary documentation consulted 28 October 2026: GitHub Hello World, ignoring files and rulesets; WordPress Backups; OpenAI Prompting Codex, linked at their relevant passages. Check current product behavior and permission availability during implementation. This document's profile thresholds, forms and teaching examples are editorial recommendations, not vendor requirements.

Edition 1.0.0-draft.3 (25 October 2026) supplied the original complete three-part family. Edition 1.0.0-draft.4 (28 October 2026) edits it for computing graduates beginning freelance website work, adds WordPress/GitHub boundaries, AI collaboration, connectivity planning, client handover and a proportionate record route. That draft remained unpublished. Version 1.0.0, 28 October 2026, activates the author-approved notice and final companion URLs; instructional guidance is unchanged.

Publication qualification: instructional prompts have not been validated through a timed learner trial. Fictional examples and results remain illustrative.

By Henok Ahmed · Educational text, tables, prompts, checklists and text templates: CC BY 4.0, with stated exclusions.

Back to top ↑