Newton Institute of Technology Logo
Newton Institute of Technology Building Your Dream Career

How to Build a Coding Portfolio: Beginner Guide

ICT Career Skills · Beginner Portfolio Tutorial

How to Build a Coding Portfolio That Shows Employers What You Can Do

Turn your coding projects into convincing evidence. Select your best work, document it, publish your portfolio and practise explaining what you built.

10 steps3 examplesHTML starter code
portfolio.js

Quick answer

How do you build a coding portfolio as a beginner?

To build a coding portfolio, choose one finished project, explain the problem and your contribution, add a clear README, and publish safe-to-share code. Then make a simple website that links to the working demonstration and repository. Test every link as a visitor, and practise explaining one decision and one test. Add more projects only when they demonstrate a useful new skill.

  • Choose
  • Document
  • Publish
  • Test
  • Explain
Starting levelBeginner
ToolsHTML + GitHub
First goal1 working project

You might have created a calculator, school revision quiz or your first HTML webpage. But how can someone else see what you are capable of building? That is what a coding portfolio is for. It makes your work visible, understandable and, where possible, testable. You do not need paid hosting or previous employment to begin.

How a coding project becomes portfolio evidence

A project

A program or website you created, such as a quiz, calculator or order tracker.

Evidence

Source code, screenshots, test notes, a live demonstration and a clear explanation.

A portfolio

A carefully arranged presentation of your projects, skills and contribution.

The goal is proof, not decoration.

Instead of writing “I know JavaScript,” show a JavaScript feature you built, describe how it works and explain how you tested it. GitHub’s career guidance recommends highlighting a small number of relevant projects that reviewers can understand quickly. [1]

Build your portfolio in 10 simple steps

Follow the steps in order. Complete your first small project before worrying about fancy colours, animations or advanced frameworks.

Choose the skills you want to demonstrate

Think about the kind of programming you enjoy. You are not expected to know everything. A portfolio should honestly represent what you have already practised.

Your interestProject evidence to show
Front-end web developmentResponsive pages, forms and interactive JavaScript
Back-end developmentAn API, input validation, test results and documented endpoints
Full-stack developmentA working interface connected to a backend and database
Python programmingA small automation tool with sample input and output
Mobile developmentApp screens and a tested demonstration on a device

Do this: Write down three skills you know and one small completed task that demonstrates each skill.

Select one to three finished projects

Choose one complete project you can demonstrate today; add other projects later if they show different capabilities. This is not a competition to collect the most project names. For a portfolio-building lesson, the next useful question is how to prove the work is yours and how a reviewer can test it.

Foundation project

For example, a small school-club webpage that is readable on a phone.

Interactive project

For example, a revision quiz that checks answers and shows a score.

Problem-solving project

For example, an order tracker or fare calculator with meaningful validation.

Selection rule

Keep the project only if you can open it, explain it, test it and identify your own contribution.

Need ideas? Read NIT’s 12 ICT Portfolio Projects for Jobs in Kenya. That guide answers what to build; this article explains how to present it.

Collect evidence for each project

Imagine an employer opens your project for the first time. They need more than a project title. Prepare a small evidence pack that helps them understand the work.

EvidenceQuestion it answers
ScreenshotWhat does the application look like?
Working demonstrationCan I try the main function?
Source repositoryHow was it created?
README and setup notesWhat is it, and how can I run it?
Test casesHow do you know it works?
Your contributionWhich parts did you personally build?

Protect other people’s information.

Use fictional customers, sample fees and demonstration accounts. Never publish passwords, student records, identification numbers, secret keys or real customer data.

Write a useful README file

A README.md is the introduction visitors see in a GitHub repository. Explain the project in plain language, then show how to run it. GitHub documents how repository READMEs work. [2]

Worked example · School revision quiz

Example README outline

Project: School Revision Quiz

Problem: Learners want to practise mathematics questions and check their answers.

Solution: An interactive ten-question quiz that calculates the final score.

Technologies: HTML, CSS and JavaScript.

My contribution: Designed the interface, wrote answer-checking logic and tested the result.

How to use: Open the demonstration, answer questions and submit the quiz.

Tests: Correct answers, wrong answers and blank responses.

Next improvement: Add subjects and difficulty levels.

Do this: Use the same headings for your own project, but describe only features you have actually built and tested.

Too vagueUseful portfolio description
“I made a quiz using JavaScript.”“I built a ten-question revision quiz. JavaScript checks answers and calculates a score. I tested correct, incorrect and blank responses.”
“I know databases.”“In a sample order tracker, I designed an orders table and tested whether changing a status saved the correct value.”

Why this works: A reader can identify a feature, your contribution and a test without guessing. Only use descriptions that accurately match your own project.

Copy-ready template: Replace the sample details below with truthful information about a project you have tested.

README.md
# School Revision Quiz ## What it doesLets learners answer ten maths questions and see a score. ## Built withHTML, CSS and JavaScript. ## How to runOpen index.html in a web browser. ## What I built and testedI wrote the scoring logic and tested correct, wrongand unanswered responses. ## Next improvementAdd more subjects and difficulty levels.

Create a GitHub repository and upload safe-to-share code

GitHub stores project files in online folders called repositories. To publish a simple project without using a terminal:

  1. Visit GitHub, sign in or create an eligible account.
  2. Choose New repository and give it a descriptive name such as school-revision-quiz.
  3. Choose Public only if the files are suitable to share.
  4. Select Create repository, then choose Add file → Upload files.
  5. Upload your project files, commit them and add the README.md.
  6. Open the public repository to verify that the README and intended files appear.

A .gitignore can exclude temporary files before you add them with Git, but it does not erase credentials already committed to a repository. Inspect files before publishing and never include passwords, secret keys or private records.

For school-age learners

GitHub accounts require users to meet GitHub’s minimum age of 13 and any higher age required by applicable law. Learners who are not eligible should use a teacher-supervised, suitable alternative. Avoid publicly sharing personal phone numbers or home addresses. [3]

Organize your GitHub profile

Your profile should explain what you are learning and direct visitors to your strongest work. Keep the introduction honest and simple:

“I am a beginner developer learning HTML, CSS, JavaScript and Python. I enjoy building small programs that solve everyday problems.”

Open your GitHub profile and select Customize your pins to feature relevant repositories. GitHub supports up to six pinned repositories and gists combined; you do not need all six. [4]

Optional: You can create a special public repository with exactly your username and add a README to show an introduction on your profile. Follow the official GitHub profile README instructions.

Plan a one-page portfolio website

A personal website is helpful, but not mandatory. A well-explained GitHub profile is enough to begin. If you choose to create a site, keep its first version simple.

Introduction

Say who you are and what you are learning, without exaggerated job titles.

Projects

Show a useful name, problem, tools, your contribution and links for each project.

Skills and contact

List skills you have practised and offer a safe, professional contact method.

Use clear headings such as About Me, My Projects, Skills and Contact. Avoid adding unnecessary animations before you have checked the actual projects.

Your project card should answer the reader in one glance

School Revision Quiz · Ten-question mathematics practice tool · Built with: HTML, CSS and JavaScript · My role: interface and scoring logic · Verified: correct, incorrect and unanswered test cases · Links: working demonstration and GitHub repository.

Use links that open the actual project, not a link to the general GitHub homepage. If a live demonstration is unavailable, link to a repository with complete setup instructions or a short demonstration recording.

Build your first webpage with HTML

HTML gives a webpage its structure. CSS improves appearance, while JavaScript adds interaction. Start with a simple page before upgrading its design.

  1. Create a folder named my-coding-portfolio.
  2. Inside it, create a file named index.html.
  3. Type or paste this starter HTML in a code editor:
index.html
<!doctype html><html lang=”en”><head><meta charset=”utf-8″><meta name=”viewport” content=”width=device-width, initial-scale=1″><title>My Coding Portfolio</title></head><body><header><h1>Hello, I build websites.</h1></header><main><h2>My Projects</h2><h3>School Revision Quiz</h3><p>My first interactive maths quiz.</p><a href=”https://github.com/YOUR-USERNAME/school-revision-quiz”> View my project code</a></main><footer><p>My learning portfolio.</p></footer></body></html>
  1. Save the file and open it in a browser. You should see a heading, a project heading and a short description.
  2. Replace YOUR-USERNAME with your own GitHub username and edit the repository name to match your real project. Add About, Skills and Contact sections, then test the project link.
  3. If you make a style.css file, place it beside index.html and link it inside the HTML head before the closing head tag.

Practice extension: Create a separate file named style.css. In the <head> section of your HTML, add <link rel="stylesheet" href="style.css">. Upload both files to the same folder. The starter example works without CSS, but its design will remain basic.

See Mozilla’s beginner guide to building your first website for more help. [5]

Publish the portfolio with GitHub Pages

Your website must be publicly accessible if an employer is to open it from a link. GitHub Pages can publish a simple static HTML, CSS and JavaScript website from a repository. [6]

  1. Create a public repository called my-coding-portfolio.
  2. Add index.html to the repository root. If you made a stylesheet, upload style.css beside it.
  3. Open repository Settings → Pages.
  4. Choose Deploy from a branch.
  5. Choose the branch containing your files (often main), choose /(root), and select Save.
  6. After the site has been published, open Visit site on the Pages settings screen.

For this example, a project website normally uses a URL such as https://your-username.github.io/my-coding-portfolio/. The website may take a few minutes to appear after you publish changes. [7]

Important limitation

GitHub Pages is for static sites. It cannot host your Python, PHP or other server-side application directly. If your portfolio links to a backend project, host the backend separately or provide a clearly explained demonstration.

What went wrong?What to check first
The published URL shows a 404 page.Check that index.html is at the top of the selected publishing folder, that the chosen branch contains it, and that the deployment completed in the repository Actions tab. [9]
The page loads but has no CSS.Check that the stylesheet filename and its relative path in the HTML match the file stored in the repository. Capital letters matter in URLs.
The GitHub button opens the GitHub homepage.Replace the sample link with the exact repository URL for your finished project.

GitHub documents both the publishing source and the static-site requirements. If you are stuck, compare your settings with its instructions before changing your design. [6] [7]

Test the result and prepare to explain it

Open your published website on a phone and computer. Pretend you have never seen the work before. Try every project link, check all text and verify that demonstrations behave as described.

  • The introduction honestly describes my skills.
  • Every link opens the correct project or demonstration.
  • My projects have understandable README files.
  • My website remains readable on a small phone.
  • Images, if used, have useful alternative text.
  • Interactive controls work with a keyboard.
  • There are no public passwords or private records.
  • I can explain my own decisions and tests.

Mozilla provides practical guidance for testing web accessibility, including keyboard use and text alternatives. [8]

Run the 60-second visitor test

Give your portfolio link to someone who has never seen your projects. They should be able to finish the following actions without asking you where to click:

  1. First 15 seconds: identify your focus and find your strongest project.
  2. Next 20 seconds: open the project demonstration or source, then find the README.
  3. Final 25 seconds: discover what you personally built, which test you ran, and how to contact you appropriately.

If the visitor gets stuck: improve the relevant label, link, project card or documentation. Retest the same route in a private browser window.

Final exercise: share one link that actually works

Open your portfolio in a private browser window, without signing in to GitHub. Can a visitor find one project, open its source, see what it does, and identify your contribution? Then place the verified portfolio URL on your CV or application.

Sample application line: “My coding portfolio includes a JavaScript revision quiz with a working demonstration, source code, a README and documented tests: [your working portfolio URL].” Replace the bracketed text with your own real link.

Three examples of how to present your work

These examples illustrate the evidence to show on a portfolio page. They are fictional teaching scenarios, not profiles of individual NIT graduates.

School mathematics quiz

Problem: Learners need quick revision feedback.

Build: Ten questions, answer checking and a final score.

Skills: HTML, CSS, JavaScript conditions and browser events.

Present it: Portfolio presentation: show the quiz link, a short 20-second walkthrough, the source repository and three scoring tests. State precisely which part you wrote.

Tailor’s order tracker

Problem: A small tailoring business needs to monitor orders.

Build: A demonstration tracker with fictional customers and statuses.

Skills: Forms, validation, data storage and state changes.

Present it: Portfolio presentation: explain one complete order-status change using fictional customer records, then link to the code or a recorded demonstration and validation tests.

Matatu fare calculator

Problem: Calculate a total for a route and passenger count.

Build: Example fare KSh 80 × 3 passengers = KSh 240.

Skills: Variables, arithmetic and invalid-input handling.

Present it: Portfolio presentation: show sample inputs and the KSh 240 calculated result, then explain how invalid passenger counts are rejected.

How to present any of them

Use this sequence: problem → what I built → tools → my contribution → test → next improvement. Be specific about your own work and show evidence rather than making claims you cannot verify.

Example project explanation for an interview

“I made a maths quiz to help students practise. HTML holds the page, CSS styles it and JavaScript checks answers. Initially, unanswered questions caused an incorrect score, so I fixed the check and tested it again. Next, I would like to add different difficulty levels.”

Mistakes to avoid when making a portfolio

  • Only showing screenshots: Include source code, working demonstrations or honest test evidence.
  • Copying a tutorial without understanding it: Practise explaining each feature and the changes you personally made.
  • Using too many untested projects: Finish and check a few useful projects first.
  • Making unrealistic claims: Do not claim thousands of users or business results without evidence.
  • Publishing private information: Use fictional records and remove secrets before uploading.
  • Ignoring mobile screens: Most reviewers may open a link on different devices.
  • Relying blindly on AI code: Understand, review and test any generated code before publishing it.

The seven-day beginner portfolio challenge

DayWhat to doWhat you should finish with
1Choose a finished projectOne project and a list of its skills
2Test the projectEvidence and a list of passing tests
3Write the READMEPurpose, setup and contribution notes
4Publish safe code on GitHubA shareable repository link
5Build a simple portfolio websiteA working index.html
6Publish and review itA public site with working links
7Fix problems and practise explaining itA portfolio you can confidently demonstrate

Seven days is a suggested practice schedule, not a requirement. It is better to take longer and understand what you are doing.

Frequently asked questions

Can I build a portfolio without professional experience?

Yes. Demonstrate personal projects, suitable school assignments or clearly attributed contributions. State which parts you built yourself and show working evidence.

How many projects should beginners include?

Begin with one complete project. Gradually build towards about three strong, relevant projects. Quality, clarity and the ability to explain your work matter more than a large count.

Is GitHub alone enough for my first portfolio?

Yes. Well-organized repositories, project READMEs and profile information can form your initial portfolio. A separate website is useful, but not compulsory.

Can I include school projects?

Yes, if you have permission to share them. Remove private information, respect other people’s work and explain your own contribution accurately.

Can I use AI while developing portfolio projects?

Yes, as an aid to learning and development. But review, understand and test the output. Never present code or functionality you cannot explain as work you independently created.

Will publishing a portfolio guarantee a programming job?

A portfolio is evidence of your skills, not an employment promise. Employers may still assess your coding fundamentals, communication, teamwork, experience and ability to solve new problems.

Your portfolio starts with one project

You do not need to master every programming language before you begin. Finish something useful. Test it. Describe what you built and why. Show the actual work. Then keep improving as you learn.

Remember: a strong portfolio makes your work easy to find, understand, verify and discuss.

Sources and further reading

  1. GitHub Docs — Using Your GitHub Profile to Enhance Your Resume.
  2. GitHub Docs — About Repository README Files.
  3. GitHub — Terms of Service.
  4. GitHub Docs — Pinning Items to Your Profile.
  5. MDN Web Docs — Your First Website.
  6. GitHub Docs — Creating a GitHub Pages Site.
  7. GitHub Docs — Configuring a Publishing Source.
  8. MDN Web Docs — Accessibility Testing.
  9. GitHub Docs — Troubleshooting 404 Errors for GitHub Pages Sites.

Related NIT learning: ICT Portfolio Project Ideas · Full-Stack Software Development Course.

Turn learning into practical skill

Register for Full-Stack Software Development at NIT

Learn to build interfaces, develop back-end logic, work with databases and APIs, test applications and present real projects. Newton Institute of Technology offers practical Full-Stack Software Development training in Migori, Kenya, with industrial attachment.

Institutional training8 months

Structured software-development training.

Industrial attachment3+ months

Practical workplace exposure.

Beginner friendlyStart with the basics

Build, test and explain your own work.