Career, Learning & Web Development Fundamentals

What Should a Junior Web Developer Put in a Portfolio in 2026?

By Obaid Tariq, Founder & Lead Engineer · Published 20 October 2026

The short answer

In 2026, a junior web developer portfolio should prove that you can own working software, not just that you can produce code. That means two or three deployed projects with tests and CI, a short write-up of a real bug you fixed, visible security basics, recorded trade-offs, and an honest note on how you used AI tools and what you changed. Hiring managers can check most of this in ten minutes, and employers should design their assessments around the same evidence, because AI now writes many first drafts for everyone.

What should a junior web developer put in a portfolio in 2026?

Two or three deployed projects that real people use or that run on realistic data, each with tests, CI, a readable README and a record of the decisions you made. Add one debugging write-up, show that you handle authentication, input validation and secrets properly, and explain honestly where AI tools helped and where you overruled them. A small, well-evidenced portfolio beats a long list of tutorial clones.

Why the bar has moved

AI coding tools are now normal for people at the start of their careers. In the Stack Overflow Developer Survey 2025, 87.6% of respondents with one to five years of experience said they use or plan to use AI tools, and 55.5% use them daily. Because almost anyone can now generate a good-looking to-do app in an afternoon, a polished screenshot no longer tells a reviewer much. What still separates candidates is evidence that you understand what you shipped: you can test it, debug it, secure it and explain why it is built the way it is.

There is also a hiring-market reason to make your evidence easy to find. Business Insider reported on 19 October 2026 that an internal Anthropic report showed junior workers falling from 27% of hires in the company's technical departments in early 2025 to 9% by June 2026, as the company used AI agents more widely. That is one AI company's own data, not a picture of the whole market, and it should not be read as one. Broad official data is steadier: the US Bureau of Labor Statistics still projects 5% employment growth for web developers and digital designers from 2025 to 2035, while noting AI may soften that growth. For the wider career outlook, see will AI replace web developers.

The core of the portfolio: two or three deployed projects

In our view, two or three serious projects are enough. Each should be live at a public URL, have its source on GitHub or a similar host, and be something a reviewer can use without asking you for help. Projects with real users, even ten people from a club, a family business or a community group, are worth far more than projects nobody has touched, because real users find the bugs and edge cases that tutorials avoid. If you can't find users, use realistic data: thousands of rows, messy inputs, slow third-party APIs and failure cases, rather than three hand-written examples.

Portfolio projects for a junior web developer: what each proves and what a reviewer will check
Project	What it proves	What a reviewer will check
A small app with real users (booking form, club membership list, shop stock tracker)	You can ship something people rely on and respond to feedback	Live URL works; issues or a changelog show fixes made after launch; error states are handled
A full-stack app with authentication and per-user data	You understand sessions, authorisation and data ownership	One user can't read another user's records; passwords aren't stored by you in plain text; protected routes are checked on the server
A data-heavy dashboard or search page on a realistic dataset	You can model data, write efficient queries and keep pages fast	Pagination or limits exist; indexes or query choices are explained; page stays usable with slow or empty responses
An integration with a third-party API (payments in test mode, maps, email)	You can read external docs and handle failure	Timeouts, retries and webhook verification; secrets kept out of the repository
A pull request merged into someone else's open-source project	You can work in an unfamiliar codebase and take review feedback	The PR discussion: how you responded to comments, whether you added tests, whether it was merged

What every project should include

Tests and CI. A handful of meaningful tests for the risky parts (authorisation, money, data changes), run automatically on every push by GitHub Actions or similar. A green CI badge that reflects real checks says more than a high coverage number.
A README a stranger can follow. What the app does, the live link, how to run it locally in a few commands, how to run the tests, and the known limitations.
Decision records. Two or three short notes in the style of an architectural decision record (ADR), which captures one decision and its rationale: why you chose this database, why server rendering here, what you gave up.
Security basics. Validate input on the server, check authorisation for every request, keep secrets in environment variables and out of Git history, and know which items in the OWASP Top 10:2025 apply to your app. Broken access control is first on that list for a reason.
Performance and accessibility checks. Run Lighthouse or a similar tool, note your Core Web Vitals (Google's web.dev treats an LCP of 2.5 seconds or less, an INP of 200 milliseconds or less and a CLS of 0.1 or less as good), and check keyboard navigation, labels and colour contrast against WCAG 2.2 level AA.
A clean commit history. Small commits with clear messages show how you work. One giant commit called "initial" hides it.

A debugging write-up

Include at least one short write-up of a real bug: what you saw, how you narrowed it down, what the cause was, how you fixed it, and the test you added so it can't come back. This is the single most persuasive item for many reviewers, because it shows the skill AI tools are weakest at replacing: working out why something is wrong in a system you understand. The Stack Overflow survey found 66% of respondents frustrated by AI solutions that are almost right but not quite, and 45.2% said debugging AI-generated code is more time-consuming. A candidate who can find the "not quite" is valuable.

Honest notes on how you used AI

Don't hide AI use, and don't let it be the headline. We recommend a short section in each README called something like "How I used AI", covering which tools you used and for what, one or two places where the suggestion was wrong or insecure and what you changed, and which parts you wrote or rewrote by hand. Reviewers increasingly assume AI was involved; what they want to know is whether you were in control. Being specific here builds trust, and it prepares you for the interview question you will almost certainly be asked. For where the line sits on a real team, see how much AI-generated code should ship.

Code review and open source

Reviewing code is now a core junior skill, because more of the job is reading code than typing it. A merged pull request to an open-source project, or thoughtful review comments on other people's PRs, shows you can read unfamiliar code, follow a project's conventions and accept feedback. Start small: documentation fixes, failing-test reproductions or issues labelled for newcomers are all legitimate first contributions.

What to leave out

Unmodified tutorial projects and course capstones, unless you substantially extended them and say what you added.
Long lists of technologies you have touched once. List what you can discuss in depth.
Dead links, apps that need a login you didn't provide, or demos on free hosting that has gone to sleep without a note explaining the delay.
Anything with real API keys or personal data committed to the repository, even if you have since deleted it from the latest commit.

If you are still building the skills behind these projects, our learning path for web development with AI sets out the order we suggest, and our modern web development workflow shows what professional practice looks like day to day.

How can employers evaluate junior web developers fairly when AI writes first drafts?

Assess the things AI can't do for the candidate: explaining their own code, spotting what is wrong with a plausible draft, debugging, and making sensible trade-offs. A ten-minute portfolio check, followed by a paid or short review-and-extend exercise that allows AI tools, gives a fairer signal than a timed puzzle with AI banned. Tell candidates in advance exactly what is allowed and how they will be assessed.

Why the old filters work less well

Take-home tasks that ask for a standard CRUD app now mostly measure whether someone used an AI tool, not whether they understand web development. Banning AI entirely creates a different problem: it tests a way of working the candidate won't use on the job, and it rewards people who happen to have memorised syntax. In our view, the fair approach is to allow the tools, be explicit about it, and assess judgement and understanding instead of output volume.

What a hiring manager can verify in 10 minutes

A ten-minute junior portfolio check: what to look at and what it tells you
Minute	Check	What it tells you
0-2	Open the live URL and try the main flow, including one wrong input	Whether it actually works and handles errors
2-4	Read the README: setup steps, limitations, the AI-use note	Communication, honesty and self-awareness
4-6	Look at CI status and open one test file	Whether tests check behaviour that matters or just exist
6-8	Open one server route or API handler and look for validation and authorisation checks	Security basics and whether the candidate understands trust boundaries
8-9	Skim the commit history and any closed issues or PRs	How they work over time and respond to problems
9-10	Read one decision record or the debugging write-up	Reasoning, trade-offs and depth of understanding

Assessment formats that hold up when AI is allowed

Walk me through your code. Ask the candidate to explain a file from their own portfolio, then ask what would break if a requirement changed. People who understand their code answer easily; people who don't, struggle quickly.
Review an AI-generated pull request. Give them a plausible PR with two or three planted issues, such as a missing authorisation check, unvalidated input or an unhandled error. Ask what they would change before merging.
Debug a failing test. A small repository with one failing test and a realistic bug. Allow any tools; ask them to talk through their reasoning.
Extend, don't build from scratch. A short task to add one feature to an existing codebase tests reading, conventions and testing, which is what juniors do in their first months.
Ask about a trade-off. "Why did you choose this database?" or "What would you do differently with ten times the users?" There is no single right answer; you are listening for reasoning.

Making the process fair

State the AI policy up front. Say which tools are allowed in each stage and whether the candidate should explain how they used them.
Keep take-home work short or pay for it. In our view, anything longer than about two hours should be paid. Long unpaid tasks filter out people with less free time, not weaker developers.
Score against a written rubric. Agree beforehand what good looks like for understanding, testing, security awareness and communication, and score each candidate on the same criteria.
Value contribution history as well as projects. Open-source PRs, community work or a single well-run project for a real user can matter more than a stack of side projects.
Don't require credentials the job doesn't need. The BLS notes that education requirements for web developers range from a high school diploma to a bachelor's degree, and that workers can demonstrate their abilities through projects or prior experience.

How we think about it as an agency

We use AI coding agents every day inside a reviewed, tested delivery process, so we have an interest in this question. When we look at early-career developers, we care less about how much code someone can produce and more about whether they can read a draft critically, write the test that proves it works, and tell us honestly when they are unsure. We think teams that stop hiring juniors altogether will struggle to find senior engineers later; the more useful response is to change what juniors are trained on, putting review, testing and debugging at the centre instead of boilerplate. You can read more about how we work, and our guide to hardening a web app against AI agent attacks shows the kind of security thinking we expect everyone on a team to grow into.

Frequently asked questions

How many projects should a junior web developer portfolio have?

In our view, two or three serious projects are enough if each is deployed, tested and documented. A reviewer will usually look at one or two in detail, so depth and quality matter more than the number of projects.

Should I say I used AI to build my portfolio projects?

Yes. Most reviewers assume AI tools were involved, so a short, specific note on which tools you used, where their suggestions were wrong and what you changed builds trust. Hiding it and then struggling to explain the code in an interview does the opposite.

Do I need a computer science degree to get a junior web developer job?

Not always. The US Bureau of Labor Statistics says education requirements for web developers range from a high school diploma to a bachelor's degree depending on the employer, and that projects or prior experience can demonstrate ability. Some employers, particularly for software developer roles, still prefer a degree.

Is junior developer hiring falling because of AI?

At some companies it appears to be. Business Insider reported that Anthropic's internal data showed junior workers falling from 27% to 9% of hires in its technical departments between early 2025 and June 2026, but that is one company's data and should not be generalised to the whole market. Official US projections still show employment growth for web and software developers.

What do hiring managers look at first in a developer portfolio?

Usually whether the live project works, then the README, tests and CI status, and one piece of server code to see how input validation and authorisation are handled. A debugging write-up or decision record helps them judge how you think.

Sources

Business Insider: This chart shows how junior-level hiring is down at Anthropic due to AI (19 October 2026) — Anthropic internal report: junior workers were 27% of hires in technical departments in early 2025 and 9% by June 2026. Company-specific figures; not representative of the wider market. Accessed 20 October 2026.
US Bureau of Labor Statistics, Occupational Outlook Handbook: Web Developers and Digital Designers — 5% projected employment growth 2025-2035; AI may soften employment growth; education requirements range from high school diploma to bachelor's degree; abilities can be demonstrated through projects or prior experience. Accessed 20 October 2026.
US Bureau of Labor Statistics, Occupational Outlook Handbook: Software Developers, Quality Assurance Analysts, and Testers — 10% projected employment growth 2025-2035; typical entry-level education is a bachelor's degree, with some employers preferring more. Accessed 20 October 2026.
Stack Overflow Developer Survey 2025: AI — 87.6% of developers with 1-5 years' experience use or plan to use AI tools, 55.5% daily; 66% frustrated by AI solutions that are almost right; 45.2% say debugging AI-generated code is more time-consuming. Accessed 20 October 2026.
OWASP Top 10:2025 — Current list of the most critical web application security risks, with Broken Access Control first. Accessed 20 October 2026.
Architectural Decision Records (adr.github.io) — Definition of an ADR as a record of a single architectural decision and its rationale. Accessed 20 October 2026.
web.dev: Web Vitals — Core Web Vitals thresholds: LCP 2.5 seconds or less, INP 200 milliseconds or less, CLS 0.1 or less, at the 75th percentile. Accessed 20 October 2026.
W3C: WCAG 2 Overview — WCAG 2.2 is the current version, with conformance levels A, AA and AAA. Accessed 20 October 2026.

Recommendations without a source are AI Dev Planner’s own engineering opinion. Platform features and prices change; check the linked pages for the current position. Found an error? See our corrections policy.

Browse all 76 questions in the SaaS & web development guide.

Hiring or mentoring developers who work with AI?

We run AI-assisted delivery with review, testing and security built in. If you're shaping how your team hires or trains early-career developers, or want a project built that way, we're happy to talk.

Start a conversation Browse all resources