5 Beginner AI Projects to Build This Weekend (Starter Code)

Short answer: A small AI portfolio demo can be a weekend project: build one form, one server-side API route, and one useful result. These five Filipino-focused ideas cover seller replies, receipts, study quizzes, barangay FAQs, and job posts. The code below is a starting point, not a complete app; API cost depends on actual token usage, and Vercel's free Hobby plan is for personal, non-commercial projects.

Most "learn AI" tutorials end at a chatbot that says hello. That doesn't get you hired or get you a client. These five projects are scoped to be finishable in a weekend, each solves a problem a Filipino actually has, and each one is portfolio-worthy because it does something specific instead of "chat with AI about anything."

#Before you start: one API key, one pattern

All five projects use the same basic pattern: take some input, send it to an LLM with a clear instruction, return the structured result. Pick one provider to start:

• OpenAI, using the Responses API with the openai npm package.
• Anthropic (Claude), using the Messages API with the @anthropic-ai/sdk npm package.

Both work fine for everything below. This guide shows OpenAI's SDK for most examples and Anthropic's for one, so you see both shapes. Get your API key from platform.openai.com or console.anthropic.com, and always load it from an environment variable, never hardcoded. Check each provider's current signup terms yourself before assuming any starting credit; free trial credit offers change and shouldn't be the reason you pick one over the other for a weekend project this size.

These snippets show the core API calls. You still need a form, input validation, error handling, a loading state, and a way to limit public usage before inviting other people to try your app. Keep the API key in a server-side environment variable.

# .env
OPENAI_API_KEY=YOUR_OPENAI_KEY
ANTHROPIC_API_KEY=YOUR_ANTHROPIC_KEY

#Project 1: Taglish customer-reply helper for online sellers

Concept mockup: a buyer message becomes an editable Taglish reply. This is an example interface, not a live app screenshot. View full size.

What it does: An online seller (Shopee, Lazada, Facebook Marketplace) pastes a buyer's message, picks a tone, and gets a polite Taglish reply drafted for them. Huge time-saver for anyone juggling dozens of chats a day.

Stack: Next.js frontend, one API route, OpenAI's Responses API.

// app/api/reply/route.ts
import OpenAI from "openai";

const client = new OpenAI(); // reads OPENAI_API_KEY from env

export async function POST(req: Request) {
  const { buyerMessage, tone } = await req.json();

  const response = await client.responses.create({
    model: "gpt-5-mini",
    input: `You are a helpful assistant for a Filipino online seller. Write a ${tone} Taglish reply to this buyer message. Keep it short and natural, the way a real seller would type it.\n\nBuyer message: "${buyerMessage}"`,
  });

  return Response.json({ reply: response.output_text });
}

Cost example: At GPT-5 mini's published $0.25 per million input tokens and $2.00 per million output tokens, 150 input and 80 billed output tokens cost about $0.00020. At 500 replies a day for 30 days, that example totals about $2.96 in API charges. Actual billed output can be higher; inspect the response usage and your provider dashboard.

Deploy: Push to GitHub, import the repo into Vercel, add your API key as a server-side environment variable, and deploy. Use the free Hobby plan only for a personal portfolio demo; a seller using it for business needs an appropriate commercial plan.

Make it portfolio-worthy: Add a "tone" selector (formal, friendly, apologetic-for-delay), log a handful of before/after examples on your portfolio page, and write one paragraph about the prompt design decisions you made.

#Project 2: Receipt and expense categorizer

Concept mockup: pasted receipt lines become expense categories that a person reviews before saving. View full size.

What it does: Upload a photo of a receipt, or type in the line items, and get them automatically sorted into expense categories (food, transport, supplies, utilities) for budgeting or small-business bookkeeping.

Stack: For a weekend build, skip OCR complexity and let the user paste receipt text; ask the model to both extract and categorize in one structured call.

import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5-mini",
  input: `Extract line items from this receipt text and categorize each as one of: Food, Transport, Supplies, Utilities, Other. Return a JSON array of objects with "item", "amount", and "category".\n\nReceipt text:\n${receiptText}`,
});

const categorized = JSON.parse(response.output_text);

Cost example: At 300 input and 300 billed output tokens, the model call is about $0.00068. At 20 receipts a day for 30 days, that example totals about $0.41. A longer receipt or response costs more.

Deploy: For a personal demo, use the same Vercel path. Store results in a Supabase table if you want persistence across sessions, with Row Level Security enabled so each user only sees their own expenses. Check hosting terms before using it for a business.

Make it portfolio-worthy: Add a monthly total chart. A receipt scanner is common; a receipt scanner with a spending dashboard is a product.

#Project 3: Study-buddy quiz generator from notes

Concept mockup: class notes become a quiz with an answer key, which the student checks against the source notes. View full size.

What it does: A student pastes their notes (reviewer, lecture transcript, textbook excerpt), and the app generates a short quiz with an answer key, useful for board exam reviewees, senior high schoolers, and college students during exam week.

Stack: This one benefits from a longer, more capable model since notes can be dense. Anthropic's Claude Haiku 4.5 is a good cost-to-quality fit here.

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic(); // reads ANTHROPIC_API_KEY from env

const message = await client.messages.create({
  model: "claude-haiku-4-5",
  max_tokens: 1024,
  messages: [
    {
      role: "user",
      content: `Generate a 5-question quiz (mix of multiple choice and short answer) from these notes, with an answer key at the end. Notes:\n\n${notesText}`,
    },
  ],
});

const quiz = message.content;

Cost example: At Claude Haiku 4.5's published $1 per million input tokens and $5 per million output tokens, 1,500 input and 500 output tokens cost about $0.004 per quiz.

Deploy: Vercel again. If you want students to save quiz history, add Supabase auth so each student's quizzes stay private to their account.

Make it portfolio-worthy: Support difficulty levels (easy/medium/hard) and let users export the quiz as a printable page. Review-center-style tools have real demand around board exam season in the Philippines.

#Project 4: Barangay FAQ chatbot over a small document

Concept mockup: the answer cites a sample FAQ. Real requirements must come from the specific barangay's current document. View full size.

What it does: A barangay, homeowners' association, or small local office uploads their FAQ document (requirements for a barangay clearance, office hours, fees) and residents can ask questions in natural language instead of calling or scrolling a long PDF.

Stack: For a weekend build, skip a full vector database. Paste the FAQ document directly into the prompt (it's small enough), and let the model answer strictly from that content.

import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5-mini",
  input: `You are a helpful assistant for a barangay office. Answer the resident's question using ONLY the information in the FAQ document below. If the answer isn't in the document, say you're not sure and suggest they visit the barangay hall directly.\n\nFAQ document:\n${faqDocument}\n\nResident's question: ${userQuestion}`,
});

Cost example: A 2,000-token FAQ sent with every question, plus 200 billed output tokens, costs about $0.00090 per question at GPT-5 mini's listed rates. At 1,000 questions, that example is about $0.90. For longer documents or heavier traffic, consider retrieval so the app sends only relevant passages. Our MCP guide explains a separate way to connect AI applications to tools and data sources.

Deploy: Vercel, with the FAQ document stored as a static file or a single Supabase row you can update without redeploying.

Make it portfolio-worthy: This is a genuinely useful civic tool. Reach out to your own barangay or a local organization and offer to actually deploy it for them; a real user beats a demo every time on a resume.

#Project 5: Job-post summarizer

Concept mockup: a long listing becomes a quick read that calls out missing pay information. View full size.

What it does: Paste a long job posting (common on OnlineJobs.ph and LinkedIn, often padded with boilerplate) and get back the essentials: role, required skills, pay range if stated, red flags (vague pay, "fast-paced environment" as the only culture description, unusually broad scope for the title).

Stack: Straightforward single-call structured extraction.

import OpenAI from "openai";
const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-5-mini",
  input: `Summarize this job posting into: Role, Key requirements (max 5 bullets), Stated pay (or "not stated"), and Notable red flags (or "none noticed"). Job posting:\n\n${jobPostText}`,
});

Cost example: A 1,000-token job post and 200 billed output tokens cost about $0.00065 at GPT-5 mini's listed rates. One thousand such summaries cost about $0.65 in this simplified example.

Deploy: Use Vercel Hobby for a personal portfolio demo. Add a browser bookmarklet or a simple paste-box UI; you don't need a browser extension for a weekend build.

Make it portfolio-worthy: Track which red flags come up most often across postings you've summarized and turn that into a short blog post or LinkedIn write-up. That's a second portfolio piece from the same project.

#Rate limits and timeouts to know about

At weekend-project traffic, you're unlikely to hit either provider's rate limits, but it's worth knowing they exist before you're debugging a mysterious 429 error at 2am.

• OpenAI rate-limits by usage tier, based on cumulative spend, across metrics like requests per minute (RPM) and tokens per minute (TPM). A new Tier 1 account (reached after roughly $5 in payments) gets meaningfully lower RPM and TPM ceilings than higher tiers, which only matters once a project gets real, sustained traffic. See OpenAI's own rate limits guide for your account's current tier and numbers.
• Anthropic rate-limits per organization across requests per minute, input tokens per minute, and output tokens per minute, also scaled by usage tier. See Anthropic's rate limits documentation for current tier thresholds.
• Timeouts matter more than rate limits for these five projects. If you deploy your API route to Vercel's free Hobby plan, functions can run up to 300 seconds before timing out, more than enough for a single LLM call, but design your frontend to show a loading state rather than assuming a response in under a second, since generation time varies with prompt and response length.

If a project you build here ever gets real traffic, that's the point to check your actual tier and limits directly in your provider dashboard rather than assuming the numbers above still apply to your account.

#Cost estimates, side by side

These are arithmetic examples using the providers' listed text-token rates on September 29, 2026, not measured bills or promises of typical usage. For GPT-5 mini, multiply input tokens by $0.25 and billed output tokens by $2.00, then divide each by one million and add them. Claude Haiku 4.5 uses $1 and $5 in the same formula. Actual output usage, including any billed reasoning tokens, may differ from the visible answer. Check current pricing and measure several real requests before setting a budget; hosting, storage, and other tools are extra.

#How to actually ship these this weekend

1. Pick one, not all five. A finished small project beats five half-built ones on a portfolio.
2. Use Claude Code, Cursor, or your AI tool of choice to scaffold the Next.js app and the API route, then read the code it writes, especially anywhere the API key gets used, to make sure it's not accidentally hardcoded or exposed to the browser.
3. Deploy to Vercel the same day you get it working locally. A live link is worth more than a screenshot.
4. Write two paragraphs about it for your portfolio: what problem it solves, and one specific technical decision you made and why.
5. Share it in our Discord. Feedback from people who'll actually try to break it is worth more than launching into silence.

#Frequently asked questions

#Which LLM API should a beginner start with?

Either OpenAI or Anthropic works fine for these projects; both have simple SDKs. Check each provider's current signup page for any trial credit, since those offers change. Pick whichever one a friend or community member already uses, so you have someone to ask when you get stuck on setup.

#How much does it actually cost to run one of these projects?

The table above shows sample calculations in US dollars using published rates. Your cost depends on the actual token counts, model, and any other services. Run several representative inputs, check billed usage in the API response or provider dashboard, and multiply by the number of requests you expect. Recheck the pricing pages before launch.

#Do I need to know machine learning to build these?

No. All five projects call an existing LLM through its API; you're writing normal application code (a form, an API route, a database call), not training or fine-tuning a model. The skill here is prompt design and basic full-stack development, not ML research.

#Where should I host these projects for free?

Vercel's free Hobby tier comfortably handles all five projects at hobby-project traffic levels. Just remember its terms restrict the Hobby plan to personal, non-commercial use, so move to a paid tier if a project starts generating revenue.

#How do I keep my API key safe when deploying?

Never hardcode it in your source files or commit it to a public GitHub repo. Set it as an environment variable in your hosting provider's dashboard (Vercel's Project Settings has an Environment Variables section), and only reference it from server-side code (API routes), never from client-side code that ships to the browser.

#Sources

• Developer quickstart, OpenAI API docs
• Pricing, OpenAI API docs
• GPT-5 mini model and pricing, OpenAI API docs
• Using the Messages API, Claude Platform Docs
• Claude models and pricing, Claude Platform Docs
• Rate limits, Claude Platform Docs
• Rate limits guide, OpenAI API docs
• Vercel Hobby Plan, Vercel Docs
• Our Supabase tutorial for beginners
• Our guide to deploying your first website for free