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.
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
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 interest | Project evidence to show |
|---|---|
| Front-end web development | Responsive pages, forms and interactive JavaScript |
| Back-end development | An API, input validation, test results and documented endpoints |
| Full-stack development | A working interface connected to a backend and database |
| Python programming | A small automation tool with sample input and output |
| Mobile development | App 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.
| Evidence | Question it answers |
|---|---|
| Screenshot | What does the application look like? |
| Working demonstration | Can I try the main function? |
| Source repository | How was it created? |
| README and setup notes | What is it, and how can I run it? |
| Test cases | How do you know it works? |
| Your contribution | Which 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 vague | Useful 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.
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:
- Visit GitHub, sign in or create an eligible account.
- Choose New repository and give it a descriptive name such as
school-revision-quiz. - Choose Public only if the files are suitable to share.
- Select Create repository, then choose Add file → Upload files.
- Upload your project files, commit them and add the
README.md. - 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.
- Create a folder named
my-coding-portfolio. - Inside it, create a file named
index.html. - Type or paste this starter HTML in a code editor:
- Save the file and open it in a browser. You should see a heading, a project heading and a short description.
- Replace
YOUR-USERNAMEwith 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. - 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]
- Create a public repository called
my-coding-portfolio. - Add
index.htmlto the repository root. If you made a stylesheet, uploadstyle.cssbeside it. - Open repository Settings → Pages.
- Choose Deploy from a branch.
- Choose the branch containing your files (often
main), choose/(root), and select Save. - 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:
- First 15 seconds: identify your focus and find your strongest project.
- Next 20 seconds: open the project demonstration or source, then find the README.
- 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
| Day | What to do | What you should finish with |
|---|---|---|
| 1 | Choose a finished project | One project and a list of its skills |
| 2 | Test the project | Evidence and a list of passing tests |
| 3 | Write the README | Purpose, setup and contribution notes |
| 4 | Publish safe code on GitHub | A shareable repository link |
| 5 | Build a simple portfolio website | A working index.html |
| 6 | Publish and review it | A public site with working links |
| 7 | Fix problems and practise explaining it | A 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
- GitHub Docs — Using Your GitHub Profile to Enhance Your Resume.
- GitHub Docs — About Repository README Files.
- GitHub — Terms of Service.
- GitHub Docs — Pinning Items to Your Profile.
- MDN Web Docs — Your First Website.
- GitHub Docs — Creating a GitHub Pages Site.
- GitHub Docs — Configuring a Publishing Source.
- MDN Web Docs — Accessibility Testing.
- 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.
Structured software-development training.
Practical workplace exposure.
Build, test and explain your own work.