Forem: Ali Shirani

100 Ways to Earn Extra Cash as a Developer 💰

Ali Shirani — Sat, 20 Sep 2025 22:46:45 +0000

Times are still tough inflation, layoffs, AI disruption but developers? We’re still in demand. Not just for jobs… but for side income.

This isn’t about “get rich quick.” It’s about leveraging your skills smartly, ethically, and sustainably.

I’ve tested, researched, and updated every single option below. All links work. All platforms are live. All advice is current as of Q2 2025.

1. Web Monetization & Attention-Based Earnings

Forget ads. Think: user-consented micro-payments.

Brave Creators (formerly Brave Rewards):

Get paid in BAT when Brave users tip you or view your content. Now requires verified identity + Uphold/Gemini wallet. Avg: $5–$50/month for small blogs/repos.

👉 Tip: Add brave://rewards/creators to your site footer.
Use Value4Value protocols (PodcastIndex, Web Monetization via Coil → now part of Stremio ecosystem).
Web Monetization Standard (ILP):

Still alive! Use <meta name="monetization" content="$ilp.uphold.com/your-pointer"> + platforms like Geyser (Bitcoin Lightning) or Stremio Wallet.

💡 Low effort, passive. Best for blogs, docs, open-source profiles.

2. API-as-a-Service (Still Hot!)

RapidAPI Hub is still the king — but now with Stripe Connect payouts, usage analytics, and team billing.

New: You can now monetize GraphQL APIs and add rate-limiting tiers.
Trend: Wrap OpenAI/Anthropic/Mistral APIs with custom logic (e.g., “Tone Analyzer for Customer Support”) → charge per call.
Free tier? Yes. Payout threshold: $50.

🚀 Starter idea: Turn any npm package into a REST endpoint using serverless (Vercel/Cloudflare).

3. Issue Bounties → Now Better Than Ever

BountySource (still active, integrates with GitHub)
GitStart — pays devs to fix OSS bugs ($50–$500/task)
Maintainer Mountaineer — bounties for docs, triage, CI fixes

💡 Pro tip: Filter by “good first issue” + “bounty” labels on GitHub.

4. Sponsorships — Smarter, Broader, Easier

GitHub Sponsors is still zero-fee and now supports monthly AND one-time donations.

New players:

OpenCollective → Now allows project-specific fiscal hosting + automated expense reports.
LFX Crowdfunding (Linux Foundation) → Grants + matching funds for CNCF, Hyperledger projects.
SustainOSS → Community grants for maintainers.
Tidelift → Still enterprise-focused. Pays $200–$2000/month for supported packages.

🎯 Action: Add .github/FUNDING.yml + link to ALL your READMEs. Even tiny repos get $5–$20/month.

5. Tips — Still Work, But Platforms Changed

Ko-fi → Still great. Now supports Shopify-like storefronts for digital goods.
Buy Me a Coffee → Now takes 5% fee (was 0%). Still clean UI.
Zooomy (crypto + fiat), Junto (community tipping), Candle (for creators under 18).
PayPal.Me → Still works, but high fees (~3.5%).

⚠️ Never beg. Just add a discreet “Found this useful? ☕” link at the end of posts/repos.

6. Corporate Funding — More Structured Now

Companies like Microsoft, Google, AWS, Vercel, Netlify now have formal Open Source Programs Offices (OSPOs).

They offer:

Logo placement in README → $100–$1000/month
Maintenance grants → Apply via their OSPO portals
Code sponsorship → Pay to prioritize features

🔍 Where to look: GitHub Sponsors “Organizations”, OpenCollective “Backers”, LFX Projects.

7. Hackathons — Still Alive, Mostly Virtual

Google Summer of Code (GSoC) → Stipend now $1500–$6600 based on country + project scope.
MLH Fellowship → Paid remote internships ($5000 stipend)
Devpost → Still the hub. Filter by “prize > $1000”.
ETHGlobal, Solana Hacker Houses → Crypto hackathons paying up to $50k in prizes.

🏆 Pro move: Build something reusable → turn it into a SaaS or template post-hackathon.

8. Dependency Funding — Easier Than Ever

npm fund → Still works. Add to package.json:

  "funding": {
    "type": "github",
    "url": "https://github.com/sponsors/yourname"
  }

Use OpenCollective’s “Dependency Dashboard”.
GitHub Sponsors → Dependency Tipping → Still manual, but growing.

📦 Even 100 weekly downloads can net you $10–$50/month. Start small.

9. Bug Bounties — More Lucrative, More Platforms

HackerOne → Still #1. Avg payout: $500–$5000 for critical web app bugs.
Immunefi → Now covers DeFi, NFT, Layer 2. Avg bounty: $10k–$250k.
@lighthouse_audit (for smart contracts), SafeBounty (by Safe{Wallet})
Bugcrowd, Intigriti → Still active. Lower payouts but faster triage.

🛡️ Learn: PortSwigger Academy + PentesterLab. Start with low-hanging fruit (XSS, IDOR).

10. Open-Core → Harder, But Possible

Still valid — but license enforcement is key.

Use Elastic License v2, MongoDB SSPL, or AGPLv3 + commercial exception.
Tools: LicenseZero, Cryptlex (for license keys + activation)

⚠️ Warning: Big corps WILL ignore licenses. Have legal counsel or use escrow services.

11. Premium Packages — Niche, But Growing

PrivJS → Dead. Use:
- PackagePhobia Pro (analytics + private registry)
- Cloudsmith / PackageCloud → Host private npm/pypi packages → charge access
- Gumroad → Sell .tgz files directly

🧩 Idea: Offer “Pro” version with TypeScript defs, priority support, extra utils.

12. Support Plans — Now Automated

Otechie → Dead. Use:
- Crisp.chat + Stripe Billing → embed chat + paywall
- Calendly Pro → $12/user → book paid support calls
- Discord + Patreon → Private channel for supporters

💬 Charge $50–$200/hr. Even 2 hrs/week = $400–$1600/month.

13. Documentation — HIGH Demand

Season of Docs (Google) → Still runs. Stipend: $2500–$7500.
Write the Docs → Conference + job board for tech writers.
Scribe (AI-powered doc generator) → sell auto-generated guides.
Julia Evans’ list → Still gold. Companies like Stripe, Vercel, Supabase hire freelance docs writers.

📖 Rate: $50–$150/page. Start by documenting YOUR projects.

14. Ethical Advertising — Still Viable

EthicalAds → Owned by Read the Docs. No tracking. Min traffic: 50k/mo. CPM: $1–$5.
Carbon Ads → Tech-only. Min: 100k/mo. CPM: $3–$10.
PlutoAds (privacy-first, crypto-friendly)

🚫 Avoid Google AdSense — low payouts, privacy-hostile.

15. Selling Code — Risky, But Possible

IndieMaker, PieceX → Dead or spammy.
Use:
- Gumroad → Sell templates, boilerplates, plugins
- ThemeForest (Envato) → WordPress, React, Vue templates ($20–$100/sale)
- Creative Market → Design + code bundles

⚠️ Always credit OSS. Never reskin without permission.

16. Selling Content — Better Tools Now

Gumroad → Still 10%. Now has Subscriptions, Pay What You Want, Bundles.
AppSumo → Still strong for lifetime deals. Takes 70% (!) but huge exposure.
Lemon Squeezy → 5% fee, built-in taxes, subscriptions.
Podia, Teachable → For courses + digital products.

🎥 Bundle: Code + Video Walkthrough + Slack Community → charge $99–$299.

17. Writing & eBooks — Self-Publishing Boom

LeanPub → Still 70%. Great for early access + updates.
Amazon KDP → Royalties now 70% if priced $2.99–$9.99.
Tapas (serialized tech stories), Medium Partner Program (if eligible).

📚 Top sellers: “AI Prompt Engineering for Devs”, “Next.js Auth Patterns”, “TypeScript Deep Dive”.

18. Grants — More $$$ Available

UPDATED LIST:

GitHub Sponsors Matching → Up to $15k/year for top OSS maintainers
Mozilla MOSS → Up to $100k for privacy/security projects
NLnet Foundation → €5k–€50k for Internet tech
OpenSSF Alpha-Omega → $50k+ for critical CVE patching
Raspberry Pi Foundation → £5k–£20k for edtech
Gitcoin Grants Round 19 → Quadratic funding for Web3/OSS
Protocol Labs Research Grants (Filecoin/IPFS), Ethereum Foundation Grants

📝 Apply early. Most require 6–12 week review cycles.

19. Hosting Events — Hybrid Is King

Revenue streams:

Ticket sales → Use Tito, Eventbrite, Lu.ma
Sponsorships → Offer logo, booth, speaking slot
Workshops → Charge $50–$200/person
Virtual → Use Hopin, StreamYard, Gather
Hackathons → Prize pool sponsored by tech cos

🎤 Start small: “React State Management Workshop” → 20 ppl @ $50 = $1000.

20. Research Studies — Higher Pay Now

Respondent.io → $50–$200/hr for dev interviews
User Interviews → $100–$300 for 60-min sessions
Testable Minds → $10–$30 for surveys
Dscout (diary studies), Lookback (usability tests)

🧪 Filter for “developer”, “engineer”, “technical” roles → higher pay.

21. Creating Courses — Platforms Evolved

Udemy → Saturated. Avg: $10/course. Avoid.
Better:
- Scrimba → Interactive coding → rev share
- Frontend Masters → Invite-only, pays well
- Egghead.io → Short lessons → $250–$500/video
- Cursor.so (AI pair-programming courses)

🎓 Bundle course + Discord community + office hours → charge $199–$499.

22. Newsletters — Substack Still Dominates

Substack → Keep 90% (after payment fees). Min payout: $100.
Buttondown → Markdown-first, cheaper ($5/mo), no lock-in.
Ghost → Self-hosted or managed. Built-in memberships.
ConvertKit → For email automation + funnels.

✉️ Niche down: “AI Engineering Weekly”, “Rust Job Alerts”, “DevRel Digest”.

23. Member-Only Sites — Easier Setup

MemberStack (for Webflow), Outseta (all-in-one), Pico (for creators)
Patreon → Still good for tiered rewards (early access, 1:1 calls)
Ghost → Built-in paywalls + newsletters

🔐 Offer: Private repo, monthly Q&A, resource library → $10–$50/month.

24. Guest Posts — Still Pays, But Be Selective

Sites that pay $100–$500/post:

Smashing Magazine
CSS-Tricks (now owned by DigitalOcean)
LogRocket Blog
freeCodeCamp (occasional paid spots)
The New Stack, Infra Cloud Blog

✍️ Pitch: “How I Reduced AWS Costs by 70% Using CDK” → solves a pain point.

25. Consulting — Still the Goldmine

Rates:

Junior: $50–$100/hr
Mid: $100–$200/hr
Senior: $200–$500/hr

Platforms:

Toptal → Vets rigorously → $60–$200/hr
Gun.io → For contract gigs
Upwork → Bid strategically → avoid race-to-bottom

🤝 Start with ex-colleagues, LinkedIn DMs, local startups.

26. Mentoring — Structured & Scalable

MentorCruise → $50–$300/month per mentee (long-term)
Codementor → $30–$100/hr (on-demand)
ADPList (free, but leads to paid gigs), Glints Expert

🧭 Specialize: “Next.js + Auth”, “AWS Cert Prep”, “Freelance Career Coaching”

27. Tutoring — Booming Post-Pandemic

Superprof → Set your rate ($30–$150/hr)
Wyzant → US-focused, handles payments
Preply → Language + tech tutoring
Schoolhouse.world (free, but builds rep)

🎓 Teach: AP Computer Science, LeetCode prep, Python for Data Science.

28. Social Media — Algorithm Changes

Monetization thresholds (2025):

YouTube → 500 subs + 3k watch hours → Super Thanks, Memberships
TikTok → 10k followers → Creativity Program Beta ($1–$5/1k views)
Instagram → 10k → Reels Play Bonus (invite-only)
Twitter/X → Needs Premium+ → Ad revenue share (tiny)
Twitch → 50 subs OR 3 concurrent viewers avg → Bits, Subs

🎥 Content: “Build X in 60 sec”, “Debugging Horror Stories”, “Tech Stack Breakdowns”

29. Brand Deals — Micro-Influencers Win

Fiverr Collabs → Brands find you
#paid, AspireIQ → For Instagram/TikTok
Koji (link-in-bio + brand collabs)

🤝 Pitch: “I’ll build a demo using your API/tool + tutorial video” → value beyond promo.

30. Streaming — Dev Streams Are Growing

Twitch → Extensions, Bits, Subs
YouTube Live → Super Chats, Memberships
Kick → Higher rev share (95%), less saturated

🎮 Stream: Pair programming, bug hunts, “Learn Rust Live”, game jams.

31. SaaS — Still the Dream

Tools to launch fast:

Stripe Billing → Subscriptions in <1 day
Lemon Squeezy → Handles global taxes
Paddle → Full merchant of record
Orb (usage-based billing), Syft (metered billing)

🚀 Idea: “AI-Powered README Generator”, “Automated PR Review Bot”, “Env Var Manager”

32. Micro-SaaS — Low Risk, High Reward

Examples:

Chrome extension that auto-fills Jira tickets from Slack
Tool that converts Figma designs to Tailwind
CLI that checks package.json for security vulns
Dashboard that tracks your GitHub streak + stats

💡 Charge $5–$20/month. 100 users = $500–$2000 MRR.

33. Browser Extensions — Still Underrated

Monetization:

Freemium → Basic free, Pro $3–$10/month
One-time purchase → $10–$50 (via Gumroad)
Donations → Ko-fi link in options page

🌟 Idea: “AI Summarize Any Page”, “Dark Mode Everywhere”, “Copy Without Tracking”

34. Mobile/Web Apps — App Stores Still Work

Apple App Store → 15% fee after $1M/yr
Google Play → 15%
PWA + Pago → Sell subscriptions without stores

📱 Idea: “Regex Tester”, “Color Contrast Checker”, “JSON Formatter Pro”

35. Websites for Small Biz — Always Needed

Stack:

Webflow → Designer-friendly
Softr + Airtable → No-code CMS
WordPress + Elementor → Still dominant

💼 Charge: $500–$5000/site + $50–$200/month hosting/support.

36. Domain Flipping — Risky, But Strategic

Tools:

NameBio → Track sold domains
ExpiredDomains.net → Find dropping names
Park.io → Park + earn from type-in traffic

🎯 Target: AI, Crypto, Climate, Health tech keywords. Buy .io, .ai, .app

37. User Testing — Higher Rates for Devs

UserTesting.com → $10–$50/test (requires mic + cam)
TryMyUI → $10/test
UserFeel → $7–$30/test
UXtweak (higher pay for technical tests)

🧑‍💻 You’ll spot UX flaws faster → more tests accepted → more $/hr.

38. Microtasking — Only If Desperate

Amazon MTurk → $2–$8/hr (avoid)
Remotasks → AI training → $10–$20/hr
Scale AI → Data labeling → $15–$30/hr (apply as “technical rater”)

⏳ Better: Automate with Python scripts → scrape, classify, submit.

39. Surveys — Skip Unless High-Demand Niche

Only worth it if you’re:

DevOps engineer
ML/AI specialist
Cybersecurity pro

Sites: Respondent.io, User Interviews, Dscout

🚫 Avoid Swagbucks, InboxDollars — pennies/hour.

40. Decentralized Nodes — Simplified

Easiest in 2025:

Storj → Rent disk space → $5–$50/month
Filecoin → More complex, higher reward
Mysterium → Run VPN node → $10–$30/month
Grass (sell unused bandwidth → browser extension → $20–$100/month)

💻 Run on old laptop/RPi. Passive income while idle.

41. Web3 Income — DYOR Still Applies

Still risky, but:

Staking → ETH, SOL, ADA → 3–8% APY
Liquidity Pools → Uniswap, Curve → 5–20% (impermanent loss risk)
Restaking (EigenLayer) → 10–15% APY on ETH

⚠️ Never invest more than you can lose. Use cold wallets. Avoid “guaranteed returns”.

42. Affiliate Marketing — Niche Down

High-commission tech programs:

DigitalOcean → $100–$200/referral
Render → $50/referral
Vercel → $50–$100
Cursor IDE ($50), Warp Terminal ($40)

📢 Disclose! Use ?ref=yourname. Write honest reviews.

43. Reseller — Leverage Existing Tools

High-margin:

Zapier → 20% recurring
Make (Integromat) → 30%
Retool → 20%
LangChain Cloud (AI agents), LlamaIndex (RAG tools)

🔄 Bundle: “CRM + Email + Slack bot” → charge setup + monthly fee.

44. Paid Trials — Still Exist

FluCamp UK → £3,500–£5,000 for 1–2 weeks
ClinicalTrials.gov → Filter “healthy volunteers” + “compensation”
DayTwo (gut microbiome) → $200–$500

🏥 Requires health screening. Not for everyone.

45. Freelancing — Avoid Race to Bottom

Best platforms:

Toptal → $60–$200/hr (rigorous screening)
Gun.io → $80–$150/hr
Arc.dev → Remote + vetted
Avoid: Fiverr (unless premium gigs), Upwork (unless established)

🎯 Specialize: “Shopify + Hydrogen”, “Web3 Smart Contracts”, “AI Fine-Tuning”

46. Speaking — Paid Gigs Are Back

Where to find:

Sessionize → Submit to CFPs
Lunch.dev → Virtual, paid ($100–$500/talk)
Meetup Pro → Charge for virtual events

🎤 Start local → record → post → attract paid invites.

47. Remote Tech Support — Higher Pay Now

SupportNinja → $20–$40/hr
Helpware → $25–$50/hr
Squadhelp (for dev tool support)

⏰ Requires SLA adherence. Best for night owls (US daytime = your night).

48. (Missing in original — ADDED) AI Prompt Engineering

Sell:

Custom prompts for ChatGPT/Claude → $5–$50/prompt
Prompt libraries → $29–$99 on Gumroad
“Prompt Engineer as a Service” → $50–$150/hr

🤖 Marketplaces: PromptBase, FlowGPT, Etsy (yes, really).

49. Investing — Still the Silent Winner

If you save $1000/month → invest in:

VTI (Total Stock Market) → 7–10% avg return
VOO (S&P 500) → same
HDV (High Dividend) → 3–4% yield + growth

📈 $1000/mo @ 8% = $180,000 in 10 years. Side hustles can’t beat compounding.

50. Better Main Job — Often the Best ROI

Switching jobs → avg 10–30% raise
Negotiate remote → save $500+/month on commute
Ask for equity → startup upside

💼 Update LinkedIn → recruiters will find YOU. Interview even if not looking.

51. Sell AI Fine-Tuned Models

Platforms:

Replicate → Deploy & monetize fine-tuned LLMs (e.g., “Legal Clause Generator v2”)
Hugging Face Spaces + Stripe → Charge per inference
Modal Labs → Serverless GPU → charge via API

💡 Example: Fine-tune Mistral on medical jargon → sell to clinics @ $0.01/query.

52. Build & Sell “AI Agent Templates”

Use:

LangChain, LlamaIndex, AutoGen
Package as .zip with config + docs → sell on Gumroad ($49–$199)
Offer “Deploy to Vercel/Replit” button

🤖 Templates: “Customer Support Bot”, “SEO Content Writer”, “Meeting Summarizer”

53. Create VS Code / JetBrains Plugins

Monetize via:

Marketplace donations (GitHub Sponsors link in README)
Pro version (extra features → Gumroad license key)
Sponsorware (unlock after sponsoring)

🔌 Idea: “AI Commit Message Generator”, “.env Validator”, “PR Checklist Assistant”

54. License Your GitHub Actions

Open-source base action → free
“Pro” version with Slack alerts, retry logic, audit logs → $5/user/month via Lemon Squeezy
Host private version on GitHub Marketplace

⚙️ Example: “Auto-deploy on PR merge + rollback if tests fail”

55. Run a Paid CLI Tool

Examples:

npx my-tool@latest --pro-key=xxx
Charge via Stripe Checkout or Paddle
Use oclif or commander.js to build

🖥️ Tools: “Generate Terraform from YAML”, “Convert Figma to Tailwind”, “Audit Dependencies”

56. Sell Digital “Dev Kits”

Bundle:

Starter templates (Next.js + Auth + DB)
Custom hooks, utils, scripts
Video walkthrough + Discord access

Sell on:

Gumroad ($99)
Lemon Squeezy ($129 w/ updates)
Product Hunt launch → boost visibility

📦 Niche: “Web3 Auth Kit”, “AI SaaS Boilerplate”, “Multi-Tenant Next.js Starter”

57. Offer “Code Review as a Service”

Platforms:

PullRequest.com → Get paid per review ($50–$150/hr)
CodeStream → Integrated into IDE → charge teams
Self-hosted: Calendly + Stripe → $100/hr blocks

👀 Specialize: “Security Review”, “Performance Audit”, “TypeScript Migration”

58. Create & Sell Obsidian Plugins/Themes

Free base plugin → Pro features locked
Sell via Gumroad or BuyMeACoffee Shop
Use Obsidian Hub to promote

🧠 Plugins: “AI Note Summarizer”, “Daily Standup Generator”, “Git History Visualizer”

59. Monetize Your Dotfiles

Yes, seriously.

Host on GitHub → free
“Pro Dotfiles Pack” → includes:
- Custom ZSH themes
- Aliases for AWS/K8s/Docker
- Auto-setup script
- Video guide
Sell for $29–$79

💻 Market to: New Mac/Linux devs, DevOps engineers, terminal purists

60. Build “Notion Integrations as Products”

Examples:

Notion → Slack auto-poster
Notion DB → CSV exporter (with filters)
AI Summarizer for Notion pages

Sell via:

Gumroad
Notion Template Gallery (apply as partner)
Charge $10–$50/user

🗃️ Bundle with template + tutorial video → higher perceived value.

61. Create & Sell Figma Plugins

Free on Figma Community → Pro version via Gumroad
Use Figma Plugin API + React
Charge one-time $15–$50

🎨 Plugins: “Export to Tailwind”, “Token Sync to CSS”, “AI Color Palette Generator”

62. Offer “Resume Optimization for Devs”

Service:

Rewrite resumes using ATS-friendly keywords
Optimize LinkedIn/GitHub profiles
Mock interviews

Charge:

$99/resume
$199 “Full Package” (Resume + LinkedIn + 1hr mock)

📄 Market on Reddit r/cscareerquestions, Blind, Twitter.

63. Run a Paid “Dev Tool Newsletter”

Examples:

“AI Tools for Devs Weekly”
“New npm Packages This Week”
“Open Source Grants Alert”

Monetize:

Sponsorships ($200–$1000/newsletter)
Paid tier for early access or deep dives ($5–$10/month)

✉️ Use Buttondown or Substack. Grow via DEV.to, Hacker News, Twitter.

64. Sell “Architecture Diagram Templates”

Formats:

Excalidraw (.excalidraw)
Draw.io (.xml)
Mermaid code snippets

Sell on:

Gumroad ($19–$49/pack)
Etsy (yes, devs buy here too)

🏗️ Templates: “AWS Multi-AZ Setup”, “Next.js + Supabase”, “Kubernetes Cluster”

65. Create “Dev Onboarding Kits”

For startups or new hires:

Local dev setup script
VS Code settings sync
Conventions doc
CI/CD checklist

Sell to:

CTOs on LinkedIn
Indie Hackers forum
AngelList startups

🚀 Price: $199–$499/company. White-label available.

66. Build & Sell Reusable Terraform Modules

Host on:

Terraform Registry (free)
“Pro” version with support, examples, multi-cloud → sell via Gumroad

☁️ Modules: “Secure EKS Cluster”, “Cost-Optimized S3”, “Zero-Downtime RDS”

67. Offer “GitHub Profile Optimization”

Service:

Rewrite bio, pin best repos
Add metrics (stars, commits, streaks)
Embed README stats, trophies, tech radar

Charge: $49–$99/profile

🌟 Upsell: “Monthly Growth Report” for $20/mo

68. Create “Cheat Sheet PDFs”

Topics:

“React Hooks Cheatsheet”
“AWS CLI Commands”
“Python Pandas One-Liners”

Sell on:

Gumroad ($5–$15)
Etsy (surprisingly good traffic)
Bundle 5 for $29

📄 Design in Figma → export as PDF. Update quarterly → “2025 Edition”

69. Sell “Interview Question Banks”

Curate by:

Company (FAANG, startups)
Role (Frontend, DevOps, ML)
Difficulty (Easy → Hard)

Formats:

PDF + Anki deck
Web app with spaced repetition

Sell: $29–$79

🎯 Source: LeetCode, Glassdoor, Blind. Add video explanations → premium tier.

70. Run a “Pair Programming Membership”

Offer:

2x 1hr sessions/month
Code review + debugging help
Career advice

Platforms:

Patreon ($49–$99/month)
Circle.so community

👯 Limit to 20 members → high-touch, high-value.

71. License Your Component Library

MIT licensed base → free
“Enterprise Theme Pack” (dark mode, admin panels, charts) → $199/license
Host on NPM + sell licenses via Keygen.sh

🧩 Stack: React + Tailwind. Include Storybook demos.

72. Create “Dev Environment VMs”

Pre-configured:

Ubuntu + Docker + Node + Python + VS Code Server
Jupyter + Postgres + Redis

Sell as:

OVA/VMDK file ($29)
Cloud image (AWS AMI, GCP Image) → $0.10/hr usage fee

💾 Market to: Bootcamp grads, data scientists, QA engineers

73. Sell “API Mocking Servers”

Use:

Mockoon, Postman Mock Server, custom Express.js
Pre-loaded with realistic data (users, products, orders)

Sell:

Downloadable config ($19)
Hosted version ($10/month)

🧪 Great for frontend devs testing without backend.

74. Offer “Dev Twitter Thread Writing”

Service:

Write viral-style threads explaining tech concepts
Thread scheduling + engagement tips

Charge:

$99/thread
$399/month (4 threads + analytics)

🐦 Clients: Startups, indie hackers, tool makers wanting exposure.

75. Create “Learning Paths” as Products

Examples:

“Go from Zero to DevOps Engineer in 90 Days”
“Build 5 AI Apps → Portfolio Ready”

Includes:

Daily tasks
Resource links
Project milestones
Community access

Sell: $99–$199

🗺️ Host on Teachable or Podia. Offer completion certificate.

76. Build “No-Code Backend for Designers”

Tool that:

Lets designers upload Figma → generates API + DB schema
Outputs Swagger docs + Postman collection

Monetize:

Freemium web app
Pro: Export to Firebase/Supabase → $29/month

🎨 Target: Webflow, Framer, Figma designers needing dynamic content.

77. Sell “Dev Culture Decks”

For engineering managers:

“How to Run Effective Retros”
“Onboarding Checklist”
“PR Review Guidelines”

Sell as:

Notion template ($29)
PDF + editable PPT ($49)

👔 Market on LinkedIn, Lenny’s Newsletter, Manager Slack groups.

78. Offer “Tech Due Diligence for Investors”

Service:

Review startup’s codebase, infra, team before investment
Deliver report: risks, scalability, tech debt

Charge: $1,000–$5,000/report

📊 Clients: Angel investors, VC associates, accelerators.

79. Create “Automated Demo Environments”

For SaaS companies:

Spin up temporary demo env on request
Pre-loaded with sample data
Self-destruct after 1 hour

Tech:

Docker + Kubernetes + OAuth
Charge company $99–$499/month

🎞️ Saves sales teams hours. Huge value for B2B tools.

80. Sell “Accessibility Audit Scripts”

Bundle:

Axe-core + Lighthouse CI scripts
PDF report generator
Remediation checklist

Sell: $79–$199

♿ Target: Agencies, gov contractors, EU companies (WCAG compliance).

81. Run “Micro-Internships” for Students

Platform:

Post projects on Parker Dewey
Pay students $200–$500 for 20–40hr gigs
You keep 80% → profit $40–$100/project

🎓 Projects: “Refactor legacy JS”, “Write Cypress tests”, “Migrate to TypeScript”

82. License Your CI/CD Pipelines

Examples:

“Zero-Downtime Deploy Pipeline”
“Auto-Security Scan on PR”
“Multi-Region Terraform Apply”

Sell:

GitLab CI YAML configs ($49)
GitHub Actions reusable workflows ($79)

🔄 Include video walkthrough + Slack support → bundle for $149.

83. Create “Dev Salary Negotiation Scripts”

Product:

Email templates
Counter-offer calculators
BATNA worksheets
Role-play scenarios

Sell: $39–$89

💰 Market to: Junior devs, bootcamp grads, career switchers.

84. Build “AI-Powered Documentation Bots”

Bot that:

Lives in Discord/Slack
Answers questions about your codebase/docs
Trained on your GitHub repo + READMEs

Sell to OSS projects or startups:

$99/month hosted
Self-host license $299

🤖 Use LangChain + ChromaDB + GPT-4-turbo.

85. Sell “Engineering Metrics Dashboards”

Pre-built:

DORA metrics (Lead Time, Deployment Freq)
PR cycle time, review depth
Incident response times

Integrates with:

GitHub, GitLab, Jira, Linear

Sell:

Grafana dashboard JSON ($99)
Hosted version ($199/month)

📈 CTOs love this. Easy upsell from free → pro.

86. Offer “Dev Rel Strategy Consulting”

Help startups:

Build dev communities
Launch SDKs
Run hackathons
Create sample apps

Charge: $150–$300/hr or $3k–$10k/project

🤝 Clients: Seed-stage startups, API-first companies, cloud platforms.

87. Create “Remote Work Policy Templates”

For engineering leaders:

Async communication guidelines
Meeting protocols
Timezone overlap rules
Tool stack recommendations

Sell as Notion/PDF: $79–$149

🌍 High demand post-2025 remote work shakeups.

88. Sell “Incident Response Playbooks”

Includes:

PagerDuty runbooks
Comms templates (Slack, email, status page)
Blameless retro guides

Formats:

PDF + Markdown
Notion template

Price: $129–$299

🚨 Target: Startups scaling fast, fintech, healthtech.

89. Build “AI Commit Message Generator SaaS”

Users:

Paste diff → get semantic commit message
CLI + VS Code extension + web app

Monetize:

Free: 10 commits/month
Pro: $5/month unlimited

✨ Simple to build. Huge pain point. Easy virality.

90. Offer “Technical Co-Founder as a Service”

For non-tech founders:

Build MVP (4–8 weeks)
Hand off with docs + training
Optional ongoing support

Charge:

$10k–$25k/project
Or 5–10% equity + cash

🤝 Find clients: YC Co-Founder Matching, Indie Hackers, Twitter.

91. Create “Dev Book Club Kits”

Each kit:

Curated book (e.g., “Clean Code”)
Chapter summaries
Discussion questions
Zoom discussion guide

Sell to:

Engineering teams ($99/team)
Bootcamps ($49/cohort)

📚 Add author AMA → premium tier.

92. Sell “Engineering Interview Scorecards”

Templates for hiring managers:

Technical rubrics
Culture fit questions
Calibration guides

Formats:

Google Sheets + Notion
PDF + editable Word

Price: $49–$99

👔 HR departments will pay. Low competition.

93. Build “Automated OSS Contribution Finder”

App that:

Scans your skills (languages, frameworks)
Finds “good first issues” matching your level
One-click apply

Monetize:

Free: basic matching
Pro: $3/month → priority issues, mentor intro

🌱 Helps juniors. Funded by sponsorships from OSPOs.

94. Offer “Dev Team Health Checks”

Deliverable:

30-page report on:
- Bus factor
- Tech debt hotspots
- CI/CD bottlenecks
- Knowledge silos

Charge: $2,000–$5,000/team

🧑‍⚕️ Like a doctor for engineering teams. Recurring clients.

95. Create “AI Pair Programmer Prompts”

Sell packs of:

“Debug this error: ___”
“Refactor this to SOLID”
“Write test for this function”

Formats:

JSON for Cursor/Warp
Text file for Copilot
VS Code snippet pack

Price: $19–$49/pack

🤖 Developers will pay to save mental energy.

96. Sell “Cloud Cost Optimization Scripts”

Bash/Python scripts that:

Find idle EC2/RDS instances
Rightsize overprovisioned clusters
Delete unattached volumes

Sell:

Per cloud provider ($79/AWS, $79/GCP)
Bundle for $129

💸 Companies waste $millions. Easy ROI for them.

97. Run “Dev Tool Beta Tester Community”

Recruit devs → get paid to test pre-release tools.

You take 20% cut.

Platforms:

Discord community (free to join)
Companies pay you $50–$200/user for qualified feedback

🧪 Partner with: Vercel, Render, Supabase, Pinecone.

98. Create “Engineering OKR Templates”

For eng managers:

Quarterly goal setting
KPIs for velocity, quality, innovation
Alignment with product

Sell as:

Notion template ($59)
Workshop + customization ($499)

🎯 Massive need. Almost no good templates exist.

99. Build “AI-Powered Standup Bots”

Slack/Discord bot that:

DMs team daily: “What did you do? Blockers?”
Summarizes for manager
Flags delays

Monetize:

Free: 5 users
Team: $10/month
Enterprise: $50/month (SSO, audit logs)

🤖 Saves managers hours. Easy to build with GPT-4 + Slack API.

100. License Your “System Design Templates”

Diagrams + docs for:

URL Shortener
Chat App
Payment Processor
Recommendation Engine

Includes:

Tradeoff analysis
Scaling paths
Failure modes

Sell: $99–$299/template

🏗️ Used by FAANG interviewees + startups building real systems.

🧭 REAL TALK — Updated for 2025

“Side hustles” sound sexy. Reality? Most earn $50–$500/month after months of work.

Exceptions: SaaS, consulting, courses — but they require serious upfront effort.

✅ Do This Instead:

Pick 1–2 methods MAX. Master them.
Automate & systemize (use AI, templates, Zapier).
Track time vs $ — if < $20/hr, stop.
Reinvest profits into better tools, courses, or outsourcing.
Protect your energy. Burnout kills more side hustles than failure.

🚫 Avoid:

“Passive income” scams
Crypto “double your money” schemes
Platforms taking >30% cut
Anything requiring you to “pay to play”

🚀 Follow Me & Support

Connect with me:

Found this useful? Support my work:

Why React Won the Front-End Race (Love It or Hate It)

Ali Shirani — Sun, 14 Sep 2025 21:30:42 +0000

Let's get one thing straight. React isn't just a front-end library. It's a religion. And if you're a front-end developer in this day and age, you're either a devout follower or a heretic using something "different" like Vue or Svelte. Congratulations on your bravery, you hipster.

For the rest of us mortals, React is the undisputed king of the component castle. It won the great front-end war, and we're all just living in its kingdom. But why? What dark magic did this "library" (yes, we'll get to that) use to capture the hearts, minds, and weekends of developers everywhere?

Grab your coffee, question your life choices, and let's dive into why you should love React... or at least pretend to at your next job interview.

1. It’s Backed by a Small, Indie Company Called... Meta

Let's start with the elephant in the metaverse: React is the brainchild of Meta (you know, the company formerly known as Facebook).

Having one of the largest tech behemoths on the planet maintaining your favorite tool is... reassuring? It’s like knowing your car is being serviced by the same people who build spaceships. Sure, they might be harvesting your data on the side, but hey, at least you know the library won't be abandoned tomorrow because the creator got a new hobby.

This corporate backing means:

A massive team of terrifyingly smart people working on it.
Insane funding for research and development.
Battle-tested at scale: It powers Facebook and Instagram, so it can probably handle your to-do list app.

Nothing says "job security" quite like hitching your wagon to the company that basically owns the internet's social graph. Just don't read the terms and conditions.

Fun Fact: There was a brief period of panic years ago over React's licensing. The community collectively lost its mind, and Facebook eventually relented and switched to the MIT license. Ah, good times.

2. "It’s a Library, Not a Framework." (Repeat Until You Believe It)

You will hear this phrase uttered by every React purist until the heat death of the universe. And they're not wrong, they're just... annoying.

A Framework (like Angular) is like buying a complete LEGO Millennium Falcon kit. It has all the pieces and a very specific set of instructions. You have to build it their way.
A Library (like React) is like being handed a giant box of LEGO bricks and told, "Go on, build a spaceship. You figure it out. It's more flexible this way."

This "flexibility" is React's greatest strength and your greatest source of pain. You get to choose your own adventure! And by adventure, I mean you get to have lengthy, soul-crushing debates about:

Category	Your Endless Options
State Management	Redux, MobX, Zustand, Jotai, Recoil, Context API...
Routing	React Router, TanStack Router, Next.js Router...
Styling	CSS-in-JS, Styled-Components, Emotion, Tailwind...
Forms	Formik, React Hook Form, or just raw pain...

The freedom is great until you're 25 dependencies deep and realize you've accidentally built a Frankenstein's monster of a package.json.

3. JSX: Or, "How I Learned to Stop Worrying and Love HTML in My JavaScript"

Remember "separation of concerns"? That quaint old idea where your HTML, CSS, and JavaScript lived in separate houses and waved politely at each other from across the street?

React bulldozed those houses and built a giant, chaotic apartment complex called JSX.

At first, it looks like a crime against nature.

It's weird. It's wonderful. And once you get used to it, going back to vanilla JS feels like writing with a chisel and stone. You start nesting components inside components inside components, creating a beautiful Russian doll of logic that only you (and maybe the compiler) can understand.

4. The Virtual DOM: Actual Magic You Don't Need to Understand

The Virtual DOM is React's secret sauce. It's the reason React is so "performant" and "blazingly fast." How does it work?

The simple explanation:
React keeps a copy of the DOM in memory (the Virtual DOM). When state changes, it creates a new Virtual DOM, compares it to the old one, and then calculates the most efficient way to update the real DOM.

The explanation you'll actually use:

"Oh yeah, the VDOM is amazing. It does, uh... diffing... and batching... for minimal updates. Super efficient."

Just nod, sound confident, and nobody will question you. The beauty is you don't have to understand the low-level details. It just works its magic in the background, making your app feel snappy while you focus on more important things, like centering a div.

5. State Management: A Journey Into Existential Dread

Passing data in React starts out simple. It's called "props." You pass data from a parent component down to a child. Easy peasy.

Then you need to pass a prop through five nested components that don't even use it. This is called prop drilling, and it's the developer equivalent of being the middle person in a game of telephone.

So, you reach for a "state management solution." Welcome to the jungle. You wanted to share one piece of information, and now you're learning about "reducers," "actions," "dispatchers," and "middleware." One wrong move, and your entire app breaks in ways that defy the laws of physics.

Developer: "I just want to know if the user is logged in."
React Ecosystem: "Have you considered using a global, asynchronous, thunk-based state container with memoized selectors?"

6. Hooks: The Shiny New Toy That Replaced the Shiny Old Toy

Remember class components? With this.setState and lifecycle methods like componentDidMount? Ah, 2018 was a simpler time.

Then, in a flash, Hooks arrived and made everything better! And by "better," I mean "completely different and with a whole new set of rules you can't break."

With Hooks like useState and useEffect, you can write functional components that have state and side effects. It's cleaner! It's more modern! It's... confusing as heck at first.

You will accidentally create an infinite loop with useEffect. It's a rite of passage. But once you master the arcane Rules of Hooks, you feel like a wizard. A very tired, frustrated wizard.

7. React Native: "Write Once, Run Everywhere*"

And the final nail in the coffin for every other framework: React Native. The promise was intoxicating: write your app once in React, and it will magically run on both iOS and Android.

The reality is more like "write once, then spend weeks debugging why it looks perfect on iOS but is a dumpster fire on a specific model of Samsung phone."

But even with its quirks, React Native is a game-changer. It brought the component-based architecture of React to the mobile world, allowing web developers to become mobile developers without having to learn Swift or Kotlin. It's a massive part of why the React ecosystem is just so darn dominant.

Conclusion: Resistance is Futile. Welcome to the Club.

So why did React win?

It had the perfect storm: the backing of a tech giant, a flexible (if chaotic) architecture, a revolutionary way of thinking about UI (JSX), and a killer ecosystem that expanded into mobile.

React isn't just a library; it's a career path. You don't have to love it. But in this market, you kind of have to use it.

So welcome. You're one of us now. Go forth, build components, manage state, and complain about why "it's not a framework." We'll see you on Stack Overflow.

I Animated Every Major Design Pattern (The Only Video You Need)

Ali Shirani — Fri, 08 Aug 2025 14:03:14 +0000

If you’ve ever cracked open a programming book, you’ve probably seen the same black-and-white diagrams for design patterns.

You know… boxes, arrows, and the occasional sad UML chart.

I decided to change that.

Instead of another lecture or 300-page PDF, I brought every major design pattern to life — fully animated, visually explained, and ridiculously satisfying to watch.

This isn’t your average “let’s talk about Singleton for 20 minutes” video.

It’s a rapid-fire, visually stunning journey through the patterns you’ve heard of (and the ones you’ve probably never used but should).

In the video, you’ll see:

Factory, Builder, Prototype — crafted like they’re straight out of a game engine.
Observer, Strategy, State — animated so you can actually see the logic unfolding.
Decorator, Adapter, Composite — built like they belong in a sci-fi UI.
And more… yes, all the big ones.

Every single pattern has color, motion, and personality — so you don’t just memorize them, you feel how they work.

💡 If you’ve ever struggled to truly “get” design patterns, this is the one video you need to watch.

🎥 Watch the full animation showcase here: ▶ I Animated Every Major Design Pattern

I Finally Built the Coolest Retro Dev Portfolio Ever! (You Won’t Believe the Tech Behind It...)

Ali Shirani — Mon, 04 Aug 2025 12:05:48 +0000

What if your developer portfolio looked like it was built in 1995... but powered by the best modern web tech?

In this guide, we’re going full retro. We’re going to build a Windows 95-themed portfolio website using React, Vite, and TypeScript. It's fast, nostalgic, and guaranteed to make recruiters do a double-take.

If you're tired of the same cookie-cutter developer portfolios, this one's for you.

Why Build a Windows 95-Style Portfolio?

✨ Stand Out: Most portfolios look the same. A retro OS-themed site instantly grabs attention.
🎓 Learn by Doing: You’ll reinforce frontend concepts by recreating a desktop environment.
🚀 Fun Factor: It's just plain cool. And memorable.

What We'll Use

React for building component-based UIs
Vite for lightning-fast builds and hot reloading
TypeScript for safety and scalability
Pixel fonts + 90s color palette for the retro feel
Custom CSS (your choice)

Key Features to Build

☑ Resume Window

Your "About Me" as a draggable Win95 window with tabs like "My Saga" and "Tech Stack."

☑ Chess Game or Minigame

A simple board or Easter egg to show off creativity.

☑ Contact Window

GitHub, LinkedIn, Email styled as Win95 UI.

☑ Start Menu

Navigation styled like the classic Windows taskbar and start button.

☑ Clippy (Optional but amazing)

Drop in a pixel-style Clippy that gives tooltips or reacts to user actions.

How to Structure the App

npx create-vite@latest my-win95-portfolio --template react-ts
cd my-win95-portfolio
npm install

Break your components like this:

/components
  Window.tsx
  Taskbar.tsx
  StartMenu.tsx
  Resume.tsx
  Contact.tsx
/assets
  clippy.gif
  retro-icons.png

Use absolute positioning and z-index to simulate draggable windows.

Retro Styling Tips

Use fonts like Perfect DOS VGA 437 or PixelOperator
Stick to colors like teal, gray, and navy
Use box-shadow and border to emulate Win95 bevels
Add hover sounds or animations for realism

Deployment

Host your finished site on:

Vercel or Netlify for free
Use a custom domain like ali95.dev for extra style

Final Result

Want to see it in action?
Watch the full tutorial → YouTube Video

Wrap Up

This isn’t just a fun project. It’s a unique way to tell your story as a developer. It shows creativity, technical skill, and a strong eye for design — all in one pixel-perfect package.

If you're job hunting or just want to build something truly yours, go retro. Go bold.

Build a Windows 95 portfolio.

Like this post?

Star the GitHub repo
Share the YouTube tutorial
Or connect with me on Twitter, LinkedIn, and GitHub

Stop Writing Spaghetti Code: An Illustrated Guide to the Design Patterns That Will Make You a Better Developer

Ali Shirani — Wed, 23 Jul 2025 22:27:01 +0000

You’ve been there. Staring at a file so tangled with dependencies that you’re afraid to even breathe on it. A function so bloated it needs its own table of contents. Code that works, sure, but it feels fragile, like a Jenga tower one pull away from collapsing.

We all start there. But what separates a junior developer from a senior architect isn't just knowing more syntax; it's knowing the secret language of structure. It's having a mental toolkit of legendary blueprints to solve common problems with elegance and foresight.

These blueprints are Design Patterns.

They aren't code you copy and paste. They are battle-tested ideas for how to organize your code to make it flexible, understandable, and robust. Today, we're not just going to learn them; we're going to visualize them. This is the illustrated guide you've been looking for.

Part 1: Creational Patterns (The Art of Making Things)

Creational patterns are all about how we create objects, giving us more flexibility than a simple new MyClass() allows.

🏭 The Assembly Line: The Factory Pattern

The Core Question: How do we create objects without specifying the exact class, and centralize the creation logic?
The "Aha!" Analogy: Imagine a car factory. You don't build the car yourself piece by piece. You tell the factory, "I want a blue sedan." The factory handles all the complex steps—welding, painting, assembly—and delivers a finished car. A Factory function does the same for your objects.
The Gist: A single function that handles the business logic of creating and returning objects for you.
When to Use It:
- When you need to create many simple, similar objects.
- When the type of object you need to create might change depending on input or environment.
The Watch Out: For very complex objects where memory is a concern, a Class might be more efficient as it shares methods via the prototype.

👑 The Most Controversial Pattern: The Singleton

The Core Question: How do we ensure there is one—and only one—instance of a class throughout our entire application?
The "Aha!" Analogy: Think of it as the manager of a global power core. Different parts of your app can plug into it to draw power or check its status, but there is only one core. You can't just build another one.
The Gist: A class that can only be instantiated once and provides a global point of access to that instance.
When to Use It:
- For managing a truly global state, like a user session or a master configuration object.
The Watch Out: This is often an anti-pattern in JavaScript. It creates global state, which can be hard to test and debug. Often, a simple exported object from a module achieves the same goal with less ceremony. Use with extreme caution.

🧬 The Master Blueprint: The Prototype Pattern

The Core Question: How does JavaScript handle inheritance and share methods between objects efficiently without wasting memory?
The "Aha!" Analogy: Imagine a master blueprint for a car. Instead of giving every car its own copy of the entire engine schematic, you give every car a live link back to the master blueprint. When a car needs to know how the engine works, it just looks at the blueprint. ES6 Classes are just a beautiful syntax built on top of this native feature.
The Gist: Objects share methods through a live link to a central prototype object, saving massive amounts of memory.
When to Use It:
- You use it every time you write a JavaScript class!
- Directly, with Object.create, when you want one object to directly inherit from another without classes.
The Watch Out: Understanding the prototype chain is fundamental to understanding JavaScript.

Part 2: Structural Patterns (The Art of Organizing Things)

Structural patterns are about how we compose objects and classes into larger, flexible structures.

🛡️ The Gatekeeper: The Proxy Pattern

The Core Question: How can we intercept and control interactions with an object?
The "Aha!" Analogy: Imagine a celebrity (the target object) and their bodyguard (the Proxy). You don't talk to the celebrity directly. You talk to the bodyguard, who can decide whether to pass your message along, log it, or reject it entirely.
The Gist: A stand-in object that wraps another object and "traps" operations like getting or setting properties, allowing you to add logic.
When to Use It:
- Validation: Rejecting invalid data before it touches your object.
- Logging/Debugging: Knowing every time a property is accessed or changed.
- Reactivity: The foundation of frameworks like Vue and MobX.
The Watch Out: Proxies add a performance overhead. Avoid them in hot paths or loops that run thousands of times per second.

♻️ The Ultimate Recycler: The Flyweight Pattern

The Core Question: How can we manage millions of similar objects without running out of RAM?
The "Aha!" Analogy: Think of a library. They don't have a unique, heavy, hard-cover book for every single copy. They have one master book object (the shared, intrinsic data like title/author) and many lightweight library cards (the unique, extrinsic data like checkout status).
The Gist: Share common data between many objects to save memory, storing only the unique state on each object.
When to Use It:
- Game development (particles, trees, enemies).
- Rendering huge datasets (spreadsheet cells, map tiles).
The Watch Out: It adds complexity. It's a trade-off: you save RAM at the cost of slightly more CPU time to look up the shared data.

🦇 The Utility Belt: The Mixin Pattern

The Core Question: How can we add reusable functionality to a class without using inheritance?
The "Aha!" Analogy: Think of Batman's utility belt. You can give any character—Batman, Robin, a random police officer—the "grappling hook" ability by just giving them that piece of equipment. You don't need to make the police officer inherit from Class Batman.
The Gist: An object containing methods that you can "mix in" by copying them onto another class's prototype.
When to Use It:
- When you want to share a specific capability (like toJSON() or log()) across many unrelated classes.
The Watch Out: Can be dangerous. Modifying prototypes directly can lead to "prototype pollution" and make it very unclear where a method is coming from. Modern JavaScript often prefers composition (like React Hooks) over mixins.

Part 3: Behavioral Patterns (The Art of Communication)

Behavioral patterns are about how objects communicate and delegate responsibility.

📢 The Town Crier: The Observer Pattern

The Core Question: How do we let multiple objects react to an event without coupling them to the object that caused the event?
The "Aha!" Analogy: A town crier (the Observable) rings a bell and shouts, "The ship has arrived!" He doesn't know or care who is listening. The baker, the merchant, and the candlestick maker (the Observers) all hear the news and react in their own way.
The Gist: An object (Observable) maintains a list of dependents (Observers) and notifies them automatically of any state changes.
When to Use It:
- The foundation of event-driven programming.
- Building UIs (a button click notifies anyone who's listening).
- Reactive programming libraries like RxJS.

✈️ The Air Traffic Controller: The Mediator Pattern

The Core Question: How can we simplify communication in a system with many interconnected components?
The "Aha!" Analogy: In a busy airport, pilots don't talk to each other to coordinate landings. That would be chaos. They all talk to the air traffic controller (the Mediator), who manages the flow of communication.
The Gist: A central object that handles all communication between a set of related components, preventing them from having to know about each other.
When to Use It:
- Complex UI forms where changes in one input affect several others.
- The Middleware pattern in web servers (like Express.js) is a linear version of this.

✅ The To-Do List: The Command Pattern

The Core Question: How can we turn a request or an action into a standalone object?
The "Aha!" Analogy: Instead of just doing a task, you write it down on a to-do list sticky note. Now that the task is an object (the sticky note), you can pass it around, put it in a queue, log it, or even add an "undo" instruction to the back of it.
The Gist: Encapsulate a request as an object, thereby letting you parameterize clients with different requests, queue or log requests, and support undoable operations.
When to Use It:
- Implementing undo/redo functionality.
- Building task queues that need to be executed later.
- Decoupling the object that invokes an operation from the one that knows how to perform it.

The Architect's Mindset

These patterns aren't rules. They are ideas. They are solutions waiting for you to find the right problem.

Don't rush to implement a Singleton just because you can. Don't build a Factory when a simple object will do. The goal is not to use as many patterns as possible. The goal is to look at the tangled mess of your code and, with a calm clarity, recognize the shape of the problem.

"Ah," you'll say. "This isn't chaos. This is just a communication problem that needs an Air Traffic Controller."

And suddenly, you're not just a coder anymore. You're an architect. Now go build something amazing.

From Zero to NPM: Building the React Component of My Dreams

Ali Shirani — Wed, 16 Jul 2025 22:27:56 +0000

Let's be real. We've all been there. You find a seemingly perfect component on NPM for that one specific feature you need—a date picker, a modal, a swipe button. You install it, you import it, and then the nightmare begins.

You try to change a color, and you have to fight through five layers of CSS specificity. You want to move the icon just a little to the left, but there's no prop for that. You end up writing hacky CSS, adding !important everywhere, and silently cursing the developer who sealed their component in a black box.

I hit this wall one too many times with swipe buttons. I wanted something that was both beautiful out of the box and completely, utterly customizable. So I decided to build my own.

This is the story of how I built a zero-dependency, fully-themed, and ridiculously flexible swipe button, and how you can build and publish your own professional components, too.

The Problem: The Monolithic Component

My first instinct, like many developers, was to build a single, monolithic component. It looked something like this in theory:

// The "Black Box" approach
<SwipeButton
  onSuccess={...}
  railText="Swipe Me"
  overlayText="Success!"
  icon={<MyIcon />}
  railStyle={{...}}
  sliderStyle={{...}}
  overlayStyle={{...}}
  // ...and a dozen more props
/>

This seems convenient at first, but it's a trap. What if a user wants to add a subtle glow inside the rail but behind the text? What if they want to use Tailwind CSS classes instead of style objects? Every new requirement adds another prop, and the component's internal logic becomes a tangled mess.

This approach offers poor Developer Experience (DX). It's rigid. It's not composable. It's not the "React way."

The "Aha!" Moment: The Compound Component Pattern

The solution came from looking at how great APIs are built, both on the web and in other libraries. Think about the standard HTML <select> element:

<select>
  <option value="1">First</option>
  <option value="2">Second</option>
</select>

You don't configure options via a giant options prop on the select element. You compose the UI by placing <option> elements inside. This is the Compound Component Pattern.

Libraries like Radix UI and Vaul have mastered this. The core idea is simple:

A parent <Root> component manages all the state and logic.
It uses React Context to pass down that state and logic to its children.
Child components (<Slider>, <Rail>, etc.) consume the context and render the UI, giving the developer full control over each part's placement and styling.

This was the path forward.

Building the Component

Armed with this new pattern, I refactored the entire component.

1. The Context

First, I defined a React Context to be the "brain" of the operation. It holds all the shared state.

interface SwipeContextType {
  isSwiping: boolean;
  sliderPosition: number;
  // ... and other necessary state
}

const SwipeContext = React.createContext<SwipeContextType | null>(null);

const useSwipeContext = () => { /* ... checks for context ... */ };

2. The `<Root>` Component

The <SwipeButton.Root> component contains all the useState, useRef, and useEffect hooks. It handles all the complex drag-and-drop logic. Crucially, it wraps its children in the SwipeContext.Provider.

It also does something magical: it injects a <style> tag with a beautiful, complete default theme.

const Root = forwardRef<HTMLDivElement, SwipeButtonRootProps>((props) => {
  // ... all the state and drag logic ...

  const contextValue = { /* ... state and functions ... */ };

  return (
    <SwipeContext.Provider value={contextValue}>
      {/* It injects its own styles! No CSS file needed for the user. */}
      <style>{defaultStyles}</style>
      <div className="swipe-button__root" {...props}>
        {props.children}
      </div>
    </SwipeContext.Provider>
  );
});

3. The Child Components

With the Root doing all the heavy lifting, the child components became beautifully simple. For example, the <Slider> component's only job is to get its position from the context and render a div.

const Slider = forwardRef<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>((props) => {
  // It consumes the context to get what it needs
  const { sliderPosition, handleDragStart, sliderRef } = useSwipeContext();

  return (
    <div
      ref={sliderRef}
      className="swipe-button__slider"
      // Applies the position via a smooth CSS transform
      style={{ transform: `translateX(${sliderPosition}px)` }}
      onMouseDown={handleDragStart}
      onTouchStart={handleDragStart}
      {...props}
    />
  );
});

Finally, I bundled them all into a single export:

export const SwipeButton = { Root, Rail, Overlay, Slider };

The Payoff: Ultimate Flexibility

This new API is a dream to use. It works perfectly out of the box with zero configuration:

import { SwipeButton } from '@my-scope/react-swipe-button';
import { ChevronRight } from 'lucide-react';

function MyComponent() {
  return (
    <SwipeButton.Root onSuccess={() => alert("Success!")}>
      <SwipeButton.Rail>
        <span>Swipe to Unlock</span>
      </SwipeButton.Rail>
      <SwipeButton.Overlay>
        <span>Unlocked!</span>
      </SwipeButton.Overlay>
      <SwipeButton.Slider>
        <ChevronRight color="black" />
      </SwipeButton.Slider>
    </SwipeButton.Root>
  );
}

But the real magic is customization. The entire default theme is built on CSS Variables. Want to create a destructive "delete" button? You don't need new props. You just override the variables.

Just add this to your CSS:

.destructive-swipe-theme {
  --sw-background: 220 20% 15%; /* A dark background */
  --sw-border: 220 20% 25%;
  --sw-slider: 0 100% 95%; /* A white slider */
  --sw-success: 0 84.2% 60.2%; /* A dangerous red */
}

And apply the class:

<SwipeButton.Root onSuccess={handleDelete} className="destructive-swipe-theme">
  {/* ... child components ... */}
</SwipeButton.Root>

That's it. You get a completely different look without ever touching the component's internal logic. This is true separation of concerns.

The Final Step: Publishing to the World

Getting the component onto NPM was the final boss. I configured my package.json with the necessary fields (main, module, types, files, etc.), used a great tool called tsup to bundle my TypeScript into standard JavaScript, and then ran the magic command:

npm publish --access public

Try It Yourself!

This journey taught me so much about component architecture, developer experience, and the power of open source. Building something out of personal frustration is one of the most rewarding things you can do as a developer.

I invite you to check out the final product.

GitHub Repository: Link to your GitHub Repo (Stars are appreciated!)
NPM Package: Link to your NPM page
Live Demo: Link to your deployed showcase

What component have you always wished was better? Maybe it's time you built it yourself.

Thanks for reading

How To Become A World-Class Software Engineer (In 6 Months).

Ali Shirani — Mon, 23 Jun 2025 19:35:56 +0000

Hey there, aspiring coding superstar! 🌟 Ever dreamed of transforming from a curious coder into a world-class software engineer—someone who builds robust systems, writes elegant code, and leads with confidence—all in just six months? It might sound like a tall order, but trust me, it’s within reach! This isn’t about quick fixes—it’s about a focused, practical journey blending hands-on projects with 12 powerhouse books. Ready to dive in and level up? Let’s go!

Why 6 Months? The Magic of Intentional Growth

Let’s be honest—mastery takes time, but six months is the perfect sprint to kickstart your ascent to world-class status. It’s long enough to dig into the essentials, yet short enough to keep your momentum roaring. Our plan isn’t a shortcut; it’s a strategic blend of reading and doing. The key? Tackling 12 carefully chosen books (2 per month) while building real projects. Think of it like training for a marathon—you build skills step by step, and before you know it, you’re crossing the finish line as a tech titan.

This approach isn’t just theory; it’s a proven path to stand out in a fast-moving industry. So, grab your laptop, a cup of coffee, and let’s map out your transformation!

The Golden Rule: Practice Fuels Theory

Here’s the heart of Our wisdom: reading should complement practice. Books are your guide, but projects are where you shine. You can’t become a world-class engineer by just reading—you need to code, break things, and fix them. This balance is your superpower.

Build projects: Start with a simple app (like a task manager) and scale up to something like a distributed system.
Read 2 books a month: Set a rhythm—dedicate weekends to reading, weekdays to applying what you learn.
Synergy is everything: Let each book inspire your next project. That’s how you turn knowledge into skill.

Imagine debugging a tricky feature and then opening a book to nail the solution. That’s the magic we’re chasing!

The 12 Books That Will Shape Your Future

Now, let’s unveil the 12 books champions—each a treasure trove of wisdom from tech legends. I’ve included images to bring them to life, along with what you’ll gain from each. These aren’t just reads; they’re your mentors. Let’s dive in!

1. The Pragmatic Programmer by Andrew Hunt and David Thomas

Why it’s a game-changer: This classic is like a wise friend guiding you through the art of coding. It’s all about mindset and process.
What you’ll learn: Core software development practices that set you up for success.

2. Designing Data-Intensive Applications by Martin Kleppmann

Why it’s a game-changer: Ready to build systems for millions? This book unravels the secrets of distributed data.
What you’ll learn: How to design scalable, reliable architectures.

3. Clean Code by Robert C. Martin

Why it’s a game-changer: Say goodbye to spaghetti code! Uncle Bob teaches you to craft readable, maintainable masterpieces.
What you’ll learn: Refactoring techniques and clean coding principles.

4. The Mythical Man-Month by Frederick P. Brooks Jr.

Why it’s a game-changer: Ever seen a project spiral out of control? This book offers timeless lessons on managing complexity.
What you’ll learn: Strategies for large-scale project success.

5. Refactoring by Martin Fowler

Why it’s a game-changer: Turn messy code into gold with practical, step-by-step techniques.
What you’ll learn: How to improve code structure without breaking it.

6. Working Effectively with Legacy Code by Michael Feathers

Why it’s a game-changer: Most real-world code is old and messy—learn to tame it like a pro.
What you’ll learn: Strategies to update and test legacy systems.

7. Software Architecture: The Hard Parts by Neal Ford, Mark Richards, Pramod Sadalage, and Zhamak Dehghani

Why it’s a game-changer: Navigate the tricky trade-offs of system design with confidence.
What you’ll learn: Better architectural decision-making.

8. Database Internals by Alex Petrov

Why it’s a game-changer: Peek under the hood of databases to master their inner workings.
What you’ll learn: Storage engines and distributed database systems.

9. Staff Engineer by Will Larson

Why it’s a game-changer: Grow into a tech leader without leaving the coding trenches.
What you’ll learn: Leadership skills for senior engineers.

10. Extreme Ownership by Jocko Willink and Leif Babin

Why it’s a game-changer: Borrow leadership principles from the military to own your projects.
What you’ll learn: Accountability and team success strategies.

11. The Philosophy of Software Design by John Ousterhout

Why it’s a game-changer: Rethink how you design software for simplicity and scalability.
What you’ll learn: Deep design principles and trade-offs.

12. Why Programs Fail by Andreas Zeller

Why it’s a game-changer: Understand bugs at their core to prevent and fix them like a detective.
What you’ll learn: Debugging and error prevention techniques.

Your 6-Month Action Plan

Let’s make this real with a month-by-month guide to keep you on track:

Month 1: The Pragmatic Programmer + Designing Data-Intensive Applications
- Project: Build a web app with a database backend.
Month 2: Clean Code + The Mythical Man-Month
- Project: Refactor an old project and document your process.
Month 3: Refactoring + Working Effectively with Legacy Code
- Project: Update a legacy codebase with tests.
Month 4: Software Architecture: The Hard Parts + Database Internals
- Project: Design a small distributed system.
Month 5: Staff Engineer + Extreme Ownership
- Project: Lead a mini-project or mentor someone.
Month 6: The Philosophy of Software Design + Why Programs Fail
- Project: Build a bug-free, well-designed app.

Aim for 5-10 hours a week per book, with equal time for coding. Join a community (like X or GitHub) to share your progress—accountability is your ally!

Why This Journey Is Worth It—and How to Start Today

This isn’t just about landing a fancy job. It’s about creating technology that solves real problems, growing into a leader, and leaving a legacy in the tech world. These six months could be the pivot point of your career. The industry waits for no one, but with this plan, you’ll outpace the curve.

So, what’s your first move? Grab The Pragmatic Programmer, fire up your IDE, and start a project. Share your journey with me—I’m rooting for you! Ready to become world-class? Let’s do this! 🚀

I Built Git in JavaScript… and You Can Too! (Step-by-Step Tutorial)

Ali Shirani — Mon, 16 Jun 2025 20:09:27 +0000

You type git commit a dozen times a day—but what actually happens when you hit Enter?

What if I told you that you could domesticate version control forever—by building your own modern Git clone from scratch?

Meet GITTY—a simplified, beautiful Git clone we’re going to build together using Node.js. By the end of this journey, you won’t just use Git—you’ll finally understand how it works under the hood.

Oh, and bonus? You’ll have an incredible project for your portfolio.

Let’s dive in.

🛠️ Setting Up Our Project

First things first—let’s initialize our Node.js project:

mkdir gitty && cd gitty  
npm init -y

The key detail here? Setting "type": "module" in package.json so we can use modern ES6 imports.

Installing Dependencies

We’ll need a few tools to make our CLI sleek and interactive:

Commander – For a professional command structure.
Inquirer – For beautiful interactive prompts.
Chalk & Figlet – For some CLI flair.

npm install commander inquirer chalk figlet

Project Structure

We’ll keep things clean with:

gitty.js (main executable)
commands/ (for modular logic)

In package.json, we add a "bin" field to make gitty.js executable:

"bin": {
  "gy": "./gitty.js"
}

Now, let’s scaffold our CLI in gitty.js:

import { program } from 'commander';
import figlet from 'figlet';
import chalk from 'chalk';

console.log(chalk.blue(figlet.textSync('GITTY')));

program
  .version('1.0.0')
  .description('A beautiful Git clone built with Node.js')
  .command('init', 'Initialize a new GITTY repository')
  .command('add', 'Stage files for commit')
  .command('commit', 'Create a new commit');

program.parse();

With this skeleton in place, we’re ready to build our first command.

🔨 Building `gitty init` – The Brain of Our System

The goal? Create a .gitty directory—our version control database.

Inside commands/init.js:

import fs from 'fs';
import path from 'path';
import chalk from 'chalk';

const init = () => {
  if (fs.existsSync('.gitty')) {
    console.log(chalk.red('GITTY repository already exists!'));
    process.exit(1);
  }

  // Create essential directories
  fs.mkdirSync('.gitty');
  fs.mkdirSync('.gitty/objects'); // Stores blobs, trees, commits
  fs.mkdirSync('.gitty/refs');    // Stores branch pointers

  // Initialize HEAD (points to current branch)
  fs.writeFileSync('.gitty/HEAD', 'ref: refs/heads/main');

  console.log(chalk.green('GITTY repository initialized!'));
};

export default init;

What’s happening?

.gitty/objects – Stores all file data (blobs) and commits.
.gitty/refs – Holds branch references (like main).
.gitty/HEAD – Tracks the currently checked-out branch.

Now, running gitty init sets up our version control brain.

📦 Implementing `gitty add` – Staging Files Like a Pro

Git doesn’t store duplicate files—it uses content-addressable storage.

When you add a file:

Its contents are hashed (SHA-1).
The hash becomes the filename inside .gitty/objects.
The mapping (filename → hash) is stored in the index.

Here’s how we do it:

import fs from 'fs';
import path from 'path';
import crypto from 'crypto';
import chalk from 'chalk';

const add = (files) => {
  const gyDir = path.resolve('.gitty');
  const indexFile = path.join(gyDir, 'index');

  let index = {};
  if (fs.existsSync(indexFile)) {
    index = JSON.parse(fs.readFileSync(indexFile));
  }

  files.forEach((file) => {
    const content = fs.readFileSync(file);
    const hash = crypto.createHash('sha1').update(content).digest('hex');

    // Save blob to objects
    fs.writeFileSync(path.join(gittyDir, 'objects', hash), content);

    // Update index
    index[file] = hash;
  });

  fs.writeFileSync(indexFile, JSON.stringify(index));
  console.log(chalk.green('Files staged!'));
};

export default add;

Now, gitty add file.txt stores the file forever in .gitty/objects.

💾 The Magic of `gitty commit` – Snapshotting History

A commit is a permanent snapshot with:

✅ Author & timestamp

✅ Commit message

✅ Tree hash (directory state)

✅ Parent hash (previous commit)

Here’s how we build it:

import inquirer from 'inquirer';
import fs from 'fs';
import path from 'path';
import crypto from 'crypto';
import chalk from 'chalk';

const commit = async () => {
  const { message } = await inquirer.prompt({
    type: 'input',
    name: 'message',
    message: 'Enter commit message:',
  });

  const gittyDir = path.resolve('.gitty');
  const indexFile = path.join(gittyDir, 'index');

  // 1. Build the tree object (represents directory structure)
  const index = JSON.parse(fs.readFileSync(indexFile));
  const tree = { files: index };
  const treeHash = crypto.createHash('sha1').update(JSON.stringify(tree)).digest('hex');
  fs.writeFileSync(path.join(gittyDir, 'objects', treeHash), JSON.stringify(tree));

  // 2. Find parent commit (if exists)
  let parentHash = null;
  const headRef = fs.readFileSync(path.join(gittyDir, 'HEAD'), 'utf-8').trim();
  const branchFile = path.join(gittyDir, headRef.split(': ')[1]);

  if (fs.existsSync(branchFile)) {
    parentHash = fs.readFileSync(branchFile, 'utf-8').trim();
  }

  // 3. Create commit object
  const commit = {
    tree: treeHash,
    parent: parentHash,
    author: 'Your Name <you@example.com>',
    message,
    timestamp: new Date().toISOString(),
  };

  const commitHash = crypto.createHash('sha1').update(JSON.stringify(commit)).digest('hex');
  fs.writeFileSync(path.join(gittyDir, 'objects', commitHash), JSON.stringify(commit));

  // 4. Update branch pointer
  fs.writeFileSync(branchFile, commitHash);

  console.log(chalk.green(`Commit ${commitHash.slice(0, 7)} created!`));
};

export default commit;

Now, gitty commit captures history forever.

🎉 The Grand Finale

Let’s test it:

npm link       # Make `gitty` globally available
gitty init        # Initialize repo
gitty add file.txt # Stage a file
gitty commit      # Create a commit

Boom! You’ve just built a functional Git clone.

🔍 Key Takeaways

✔ Blobs – Hashed file contents.

✔ Trees – Snapshots of directories.

✔ Commits – Immutable history points.

✔ Branches – Just pointers to commits.

Now, you understand Git deeply—not just use it.

🚀 What’s Next?

Want to extend Gitty? Try:

Branching (gitty branch)
Checking out commits (gitty checkout)
Remote repositories (gitty remote)

What feature should we add next? Drop a comment below!

If you enjoyed this deep dive, smash that like button, subscribe, and share with fellow devs.

Happy coding! 🚀

How I Made GitHub Issues Hilarious! Build Your Own Github Bot.

Ali Shirani — Wed, 11 Jun 2025 18:38:33 +0000

Okay, this is going to be FUN! Building a bot that slings GIFs into GitHub issues? Sign me up! Let's transform this awesome tutorial into a blog post that'll have developers everywhere scrambling to build their own GIF-slinging sidekick.

Here we go!

Level Up Your GitHub Game: Build an Automated GIF Bot (From Scratch!) ✨🤖

Ever been in a GitHub issue, deep in a technical discussion, and thought, "You know what this conversation really needs? A perfectly timed GIF!" Of course, you have. We all have. Manually searching and pasting GIFs is so 2023. What if you could summon the perfect GIF with a simple command, right there in the issue?

Well, buckle up, buttercup, because that's exactly what we're building today! We're diving headfirst into creating a fully functional GitHub GIF Bot from scratch, leveraging the latest and greatest official GitHub libraries. By the end of this guide, you'll have your very own bot, ready to inject a healthy dose of fun and expression into any repository.

Ready to become a GitHub legend? Let's get into it!

Step 1: Birth Your Bot - Registering as a GitHub App 👶

First things first, our bot needs an identity on GitHub. Think of it like getting its official GitHub passport.

Navigate to GitHub Apps: Head to your GitHub Settings > Developer settings > GitHub Apps.
New GitHub App: Click that shiny "New GitHub App" button.
Name Your Creation: Give your bot a cool, memorable name. I'm calling mine "GiphyBot Deluxe," but you do you!
Homepage URL: This can be anything for now – even your GitHub profile URL works.
The All-Important Webhook URL (with a Smee.io Detour!):
- This is CRITICAL. For local development, we need a public URL that tunnels requests to our local machine.
- Open a new tab and go to smee.io.
- Click "Start a new channel."
- Copy the "Webhook Proxy URL" it gives you. It'll look something like https://smee.io/YourUniqueChannel.

*   Paste this Smee.io URL back into the "Webhook URL" field on GitHub.

Webhook Secret: This is like a password for your webhooks, ensuring they're legit.
- Generate a strong, random string (use a password manager or online generator).
- SAVE THIS SECRET! Put it in a secure note-taking app or password manager. We'll need it soon.
Permissions - The Need-to-Know Basis: For security, our bot only needs two things:
- Scroll to "Repository permissions."
- Find Issues and set it to Read & write.
- Just below that, find Pull requests and also set it to Read & write.
Subscribe to Events: We need to tell GitHub what our bot cares about.
- Under "Subscribe to events," check the box for Issue comment.
Create GitHub App: Leave everything else as default and hit that glorious "Create GitHub App" button.

Phew! On the next page, take note of the App ID (you'll need it). Scroll down and click "Generate a private key." This will download a .pem file.

🚨 SECURITY ALERT! 🚨
Treat this .pem file like the master key to your kingdom. NEVER, EVER commit it to your repository. Keep it secret, keep it safe!

Step 2: Unleash the GIFs - Getting Your Giphy API Key 🔑

Our bot needs to talk to the GIF gods at Giphy.

Head over to developers.giphy.com.
Create an account or log in.
Click on "Create an App."
Choose the "API" option (not SDK).
Give your Giphy app a name and description.
BAM! You'll get an API Key. Copy it.
Add this Giphy API Key to your collection of secrets (with your App ID, Webhook Secret, and the path to your .pem file).

Step 3: Setting Up Shop - Project & Dependencies 💻

Alright, with our keys and secrets gathered, it's time to write some code!

Create Your Project: Open your favorite code editor and terminal. Make a new project directory:
```
mkdir github-gif-bot
cd github-gif-bot
npm init -y
```
Install the Magic (Packages): We're using ESM syntax, so we need a few specific packages.
```
npm install express octokit @octokit/webhooks dotenv axios
```

*   `express`: For our web server.
*   `octokit`: The official GitHub client library.
*   `@octokit/webhooks`: To handle incoming GitHub webhooks.
*   `dotenv`: To manage our secrets from an environment file.
*   `axios`: To make HTTP requests to the Giphy API.

Create Your Files:
- index.js: This will be our main bot code.
- .env: This is where our precious secrets will live, safely outside our code.
- .gitignore: Add .env and node_modules/ to this file!

Populate .env: Open your .env file and add your secrets like this:

APP_ID=your_app_id_here
WEBHOOK_SECRET=your_webhook_secret_here
PRIVATE_KEY_PATH=./your_downloaded_private_key.pem  # Or the full path
GIPHY_API_KEY=your_giphy_api_key_here
PORT=3000 # Or any port you prefer

(Make sure your .pem file is in the location you specify, or update the path).

Step 4: The Brains of the Operation - Code Breakdown 🧠

Open up index.js. Let's walk through the code that brings our bot to life.

// index.js
import express from 'express';
import { App } from 'octokit';
import { createNodeMiddleware } from '@octokit/webhooks';
import dotenv from 'dotenv';
import fs from 'fs'; // To read the private key
import axios from 'axios'; // For Giphy API calls

// Load environment variables
dotenv.config();

const app = express();
const port = process.env.PORT || 3000;

// Read the private key
// Ensure your .env file has PRIVATE_KEY_PATH pointing to your .pem file
const privateKey = fs.readFileSync(process.env.PRIVATE_KEY_PATH, 'utf8');

// Initialize our GitHub App instance
const githubApp = new App({
  appId: process.env.APP_ID,
  privateKey: privateKey,
  webhooks: {
    secret: process.env.WEBHOOK_SECRET,
  },
});

// The heart of our bot: Listening for issue comments
githubApp.webhooks.on('issue_comment.created', async ({ octokit, payload }) => {
  console.log('Received an issue_comment.created event');

  const commentBody = payload.comment.body;
  const commenter = payload.comment.user.login;
  const botUsername = (await octokit.rest.apps.getAuthenticated()).data.slug + '[bot]'; // Gets the bot's username like "app-name[bot]"

  // 1. Check if the comment starts with /gif
  // 2. Check if the comment is NOT from the bot itself (to avoid infinite loops!)
  if (commentBody.startsWith('/gif') && commenter !== botUsername) {
    console.log(`GIF command detected from ${commenter}: ${commentBody}`);
    const searchQuery = commentBody.substring(5).trim(); // Get text after "/gif "

    if (searchQuery) {
      try {
        // Fetch GIF from Giphy
        const giphyResponse = await axios.get('https://api.giphy.com/v1/gifs/search', {
          params: {
            api_key: process.env.GIPHY_API_KEY,
            q: searchQuery,
            limit: 1, // Get the top GIF
            offset: Math.floor(Math.random() * 25), // Get a bit of randomness
            rating: 'g', // Keep it SFW
            lang: 'en',
          },
        });

        if (giphyResponse.data.data && giphyResponse.data.data.length > 0) {
          const gifUrl = giphyResponse.data.data[0].images.original.url;
          const replyComment = `Here's a GIF for "${searchQuery}":\n\n![${searchQuery}](${gifUrl})`;

          console.log(`Replying with: ${replyComment}`);

          // Post the GIF as a new comment
          await octokit.rest.issues.createComment({
            owner: payload.repository.owner.login,
            repo: payload.repository.name,
            issue_number: payload.issue.number,
            body: replyComment,
          });
          console.log('GIF comment posted successfully!');
        } else {
          console.log(`No GIF found for "${searchQuery}"`);
          await octokit.rest.issues.createComment({
            owner: payload.repository.owner.login,
            repo: payload.repository.name,
            issue_number: payload.issue.number,
            body: `Sorry, I couldn't find a GIF for "${searchQuery}". 😕`,
          });
        }
      } catch (error) {
        console.error('Error fetching from Giphy or posting to GitHub:', error);
         await octokit.rest.issues.createComment({
            owner: payload.repository.owner.login,
            repo: payload.repository.name,
            issue_number: payload.issue.number,
            body: `Oops, something went wrong while I was fetching your GIF. Please try again!`,
          });
      }
    } else {
      console.log('Empty search query after /gif');
       await octokit.rest.issues.createComment({
            owner: payload.repository.owner.login,
            repo: payload.repository.name,
            issue_number: payload.issue.number,
            body: `You need to tell me what GIF to search for! Usage: \`/gif <search term>\``,
          });
    }
  }
});

// Standard Express server setup
// Use the Octokit webhook middleware
app.use(createNodeMiddleware(githubApp.webhooks, { path: '/api/github/webhooks' }));

app.listen(port, () => {
  console.log(`Server listening for webhooks at http://localhost:${port}/api/github/webhooks`);
});

Key Parts Explained:

Imports & Setup: We grab express, App from octokit, createNodeMiddleware, dotenv, fs (for reading the private key file), and axios. We initialize Express and load our .env variables.
GitHub App Initialization: We create an instance of our App, passing in the appId, privateKey (read from the file), and webhookSecret.
githubApp.webhooks.on('issue_comment.created', ...): This is the core listener.
- It triggers whenever a new issue comment is created on a repository where our app is installed.
- It gives us:
  - octokit: A pre-authenticated Octokit client instance. This is how our bot performs actions (like posting comments) AS ITSELF. Magic!
  - payload: All the data about the event (who commented, what they said, where it happened, etc.).
Logic Inside the Listener:
1. We grab the commentBody and the commenter.
2. We also fetch the bot's own username to prevent it from replying to its own GIF posts (crucial for avoiding infinite loops of GIF-ception!).
3. We check if the comment startsWith('/gif') AND if the commenter isn't our bot.
4. We extract the searchQuery (the text after /gif).
5. We use axios to hit the Giphy API with our search query.
6. We construct a replyComment using Markdown to embed the GIF image.
7. Finally, we use octokit.rest.issues.createComment({...}) to post our GIF-laden reply back to the GitHub issue.
Express Server: The rest is standard Express setup, telling our app to listen for incoming webhook requests on /api/github/webhooks (or whatever path you configured in Smee/GitHub).

Step 5: Showtime! Running & Testing Your Bot 🚀

The moment of truth! Let's bring our GIF-tastic creation to life.

Start the Smee.io Tunnel (Terminal 1):
- Remember that Smee.io URL? We need to tell the Smee client to forward requests from that public URL to our local server.
- First, if you haven't already, install the Smee client globally:
```
npm install --global smee-client
```

*   Then run the client, replacing `YOUR_SMEE_CHANNEL_URL` with the URL Smee.io gave you, and `/api/github/webhooks` if you used a different path:

    ```bash
    smee --url YOUR_SMEE_CHANNEL_URL --path /api/github/webhooks --port 3000
    ```

    (Ensure the `--port` matches the port your Node.js app is listening on, and `--path` matches the webhook path in your `index.js` and GitHub App settings).
    You should see it connect and say "Forwarding `YOUR_SMEE_CHANNEL_URL`/api/github/webhooks to http://localhost:3000/api/github/webhooks". Perfect!

Start Your Bot Server (Terminal 2):
- In a new terminal window, navigate to your project directory and run:
```
node index.js
```

*   You should see "Server listening for webhooks at http://localhost:3000/api/github/webhooks".

Install Your App on a Repository:
- Go back to your GitHub App's settings page on GitHub.
- Click "Install App" in the left sidebar.
- Choose a test repository (or create a new one) to install your bot on. Grant access.
Test Drive!
- Go to the repository where you just installed the app.
- Create a new issue, or open an existing one.
- In a comment, type: /gif happy cat
- Hit "Comment."
If all goes well...
- You'll see activity in your Smee client terminal (a webhook being received).
- You'll see logs in your node index.js terminal (event received, talking to Giphy, posting back).
- And then... BOOM! Your bot should post a comment with a happy cat GIF!

🎉 You Did It! Your GitHub Is Now More Awesome! 🎉

How cool is that? You've just built a fully automated GitHub bot that brings joy, laughter, and a whole lotta GIFs to the often-serious world of software development.

This is just the beginning. You can expand this bot to do all sorts of cool things:

Add more commands.
Integrate with other APIs.
Help automate repository tasks.

Thanks for building along, and happy coding! See you in the next one!

10 Design Patterns Every Developer Should Know

Ali Shirani — Wed, 28 May 2025 13:52:06 +0000

Okay, this is going to be FUN! We're diving into the secret sauce that transforms code from a tangled mess into a work of art (or at least, something your colleagues won't curse you for). Get ready to level up your developer game!

From Play-Doh Snakes to Architectural Marvels: 10 Design Patterns You NEED to Know!

Ever feel like your early code resembled those colorful, slightly lumpy Play-Doh snakes we all proudly made as kids? You're not alone! We've all been there. Then, as you journey towards becoming a seasoned developer, you start hearing whispers of "design patterns." Suddenly, your code begins to take on the elegance and structure of the Sistine Chapel.

But here's a little secret from the trenches: sometimes, when you reach that principal engineer peak, you realize maintaining a digital Sistine Chapel for every simple website is... overkill. And you find a new appreciation for the elegant simplicity of well-crafted Play-Doh snakes.

The truth lies somewhere in between. Today, we're unlocking 10 essential software design patterns – powerful, battle-tested solutions to common problems you'll face every single day. We'll explore their pros, their cons (yes, they have them!), and when to whip them out of your coding toolkit.

This isn't just about memorizing syntax; it's about understanding how to solve problems effectively. Think of these patterns not as rigid rules, but as blueprints from the legendary "Gang of Four" (the authors of the seminal "Design Patterns" book) and beyond, categorized into:

Creational Patterns: How objects get made.
Structural Patterns: How objects connect and relate.
Behavioral Patterns: How objects talk to each other.

A Word of Caution: These patterns are like power tools. In the right hands, they build masterpieces. Used carelessly, they can add unnecessary complexity. The goal isn't to sprinkle them everywhere, but to recognize when they genuinely simplify and strengthen your code.

Alright, let's roll up our sleeves and get to it!

1. The Singleton Pattern: The "One Ring to Rule Them All"

The Gist: Ensures a class has only one instance and provides a global point of access to it. Think of it like the main settings object for your app – you only need one!
How it Works (Conceptually):
- The constructor is made private, so you can't just new it up willy-nilly.
- A static method (getInstance()) checks if an instance already exists. If yes, it returns it. If not, it creates one, stores it, and then returns it.
The Catch in JavaScript: JavaScript's object literals and module system often give you Singleton-like behavior out of the box. A simple global object or a module exporting an object can achieve the same thing with less boilerplate. > Key Takeaway: "Lean on your language's built-in features before implementing a fancy design pattern." – Wise words from the video!

2. The Prototype Pattern: The "Clone Machine"

The Gist: Creates new objects by copying an existing object (the prototype), rather than instantiating a new one from a class in the traditional sense. It's like cloning sheep!
Why Bother? It can be an alternative to complex class inheritance hierarchies, especially in dynamic languages. You create a base object, and then new objects "inherit" from it by being cloned and then customized.

In JavaScript: JavaScript has prototypal inheritance built-in! Object.create() is your friend here. You pass it the object you want to clone (the prototype), and it gives you a new object linked to the original.

// Super simplified concept
const zombiePrototype = {
    eatBrains: function() { console.log("Yummy brains!"); }
};

const steveTheZombie = Object.create(zombiePrototype);
steveTheZombie.name = "Steve";

steveTheZombie.eatBrains(); // Works!
console.log(steveTheZombie.name); // Steve

Interesting Tidbit: When you access a property on a JavaScript object, if it's not found, JavaScript walks up the "prototype chain" looking for it on its parent objects.

3. The Builder Pattern: The "Custom Sandwich Order"

The Gist: Separates the construction of a complex object from its representation, allowing you to create different variations of an object step-by-step. Think of ordering a custom Subway sandwich – you pick the bread, then the meat, then the veggies, one step at a time.
Problem Solved: Avoids constructors with a million parameters (telescoping constructors) and makes object creation more readable and flexible.

How it Looks: Often uses method chaining. Each method sets a part of the object and returns this (the instance itself), so you can chain the next call.

// Conceptual hotdog stand
class HotDog {
    constructor() { this.toppings = []; }
    addKetchup() { this.toppings.push('ketchup'); return this; }
    addMustard() { this.toppings.push('mustard'); return this; }
    addRelish() { this.toppings.push('relish'); return this; }
    serve() { console.log(`Serving hotdog with: ${this.toppings.join(', ')}`); return this; }
}

new HotDog().addKetchup().addMustard().serve();

Relevance: You've seen this in libraries like jQuery. While still useful, it's sometimes seen as a bit "last season" in modern JS, but the core idea of constructing objects step-by-step is timeless.

4. The Factory Pattern: The "Component Vending Machine"

The Gist: Instead of directly using the new keyword to create objects, you call a dedicated function or method (the "factory") to do it for you.
Why? It decouples your code from concrete classes. The factory can decide which specific type of object to create based on some logic (e.g., environment, user input).
Practical Example: Imagine a cross-platform app. You need a button. Instead of if (isIOS) new IOSButton() else new AndroidButton(), you have a ButtonFactory.createButton() that handles that logic internally.
Benefit: Makes your code more maintainable and easier to extend with new types of objects without changing the client code that uses the factory.

5. The Facade Pattern: The "Simple Remote Control"

The Gist (Structural): Provides a simplified, higher-level interface to a complex subsystem of components. It's like the clean, simple face of a building that hides all the messy plumbing, electrical, and structural shenanigans inside.
Problem Solved: Hides complexity. Makes a complex system easier to use by providing a "good enough" interface for most common tasks.
Analogy: Think of jQuery. It provided a much simpler way to interact with the often-clunky browser DOM APIs. You didn't need to know all the low-level details; jQuery gave you a friendly facade.
Key Idea: You're not preventing access to the underlying systems, just offering an easier entry point.

6. The Proxy Pattern: The "Bodyguard" or "Substitute"

The Gist (Structural): Provides a surrogate or placeholder for another object to control access to it. Like a substitute teacher filling in for the real one, or a bodyguard controlling who gets to see the VIP.
Why Use It?
- Lazy Loading: Only load a large object when it's actually needed.
- Access Control: Check permissions before allowing an operation.
- Logging/Caching: Intercept calls to add logging or cache results.
- Reactivity (like in Vue.js): When you change data on a proxy object, Vue's reactivity system can intercept that change (via get and set handlers) and update the UI.
In JavaScript: The Proxy object is a native feature, perfect for implementing this!

7. The Iterator Pattern: The "Guided Tour"

The Gist (Behavioral): Provides a way to access the elements of an aggregate object (like an array or list) sequentially without exposing its underlying representation. Think of a "Next" button on a music player.
Already Familiar: If you've used a for...of loop in JavaScript to go through an array, you've used the Iterator pattern!
Custom Iterators: You can create your own! For example, the video mentions creating a range iterator in JavaScript to iterate a certain number of times at a specific interval. This involves defining an object with a next() method that returns an object with value and done properties.
```
// Conceptual: How a for...of loop might work with an iterator
// const myArray = [1, 2, 3];
// for (const item of myArray) { /* ... */ }
// myArray must have a [Symbol.iterator]() method that returns an iterator object.
```
Core Idea: Separates the traversal logic from the collection itself. It's a "pull-based" system – you ask for the next item.

8. The Observer Pattern: The "News Subscription"

The Gist (Behavioral): Defines a one-to-many dependency between objects so that when one object (the "subject" or "publisher") changes state, all its dependents ("observers" or "subscribers") are notified and updated automatically.
Real-World Analogy: Subscribing to a YouTube channel. When the creator posts a new video (state change), all subscribers get a notification.
Use Cases: Event handling, UI updates (like Firebase data syncing to clients), reactive programming (RxJS is a prime example).
Key Idea: It's a "push-based" system. The subject pushes updates to its observers.

9. The Mediator Pattern: The "Air Traffic Controller"

The Gist (Behavioral): Defines an object (the "mediator") that encapsulates how a set of objects interact. Instead of objects talking directly to each other (a messy many-to-many web), they all talk to the mediator, which coordinates their actions.
Analogy: An air traffic controller. Airplanes don't talk directly to all other airplanes and runways; they communicate with the controller, who manages landings and takeoffs.
Problem Solved: Reduces coupling between objects. Makes it easier to change the interaction logic because it's centralized in the mediator.
Example: Express.js middleware. An incoming request (airplane) goes through middleware (the mediator system) which can transform it before it reaches its final handler (the runway).
Benefit: Promotes looser coupling and better separation of concerns.

10. The State Pattern: The "Mood Ring" Object

The Gist (Behavioral): Allows an object to alter its behavior when its internal state changes. The object will appear to change its class.
Problem Solved: Avoids massive if/else if/else or switch statements based on an object's state. Instead, you encapsulate state-specific behavior in separate "state" objects.
How it Works:
1. Define a base "state" interface/class.
2. Create concrete state classes that implement this interface, each with its own behavior for the methods.
3. The main object (the "context") holds a reference to a current state object.
4. When a method is called on the context, it delegates the call to its current state object.
5. The context or the state objects can transition the context to a new state.
Example: A Human object whose think() method behaves differently based on its mood (HappyState, SadState, AngryState). Instead of a switch statement in Human.think(), the Human object delegates to this.mood.think().
Benefit: Makes an object's behavior predictable and easier to manage as the number of states grows. Related to the concept of Finite State Machines (FSMs).

Beyond the Blueprints: Making Patterns Work for YOU

Phew! That was a whirlwind tour. Remember, these design patterns are tools, not commandments carved in stone. The real skill lies in:

Recognizing when a problem you're facing has a known pattern-based solution.
Understanding the trade-offs of applying a particular pattern.
Adapting the pattern to fit your specific context and programming language.

Becoming a proficient software engineer isn't just about knowing a language's syntax; it's about wielding these powerful problem-solving techniques to build robust, maintainable, and elegant software.

Now, over to you! Which of these design patterns do you find yourself using most often? Are there any others you think every developer should know? Share your thoughts in the comments below!

How to OVER Engineer a Website // What is a Tech Stack?

Ali Shirani — Tue, 27 May 2025 13:17:20 +0000

Okay, let's slice into this juicy topic! You've got that billion-dollar startup idea bouncing around your brain, ready to disrupt industries and make Zuck sweat. But hold your horses, aspiring tech mogul! Before you can even think about IPOs and private jets, you need to choose your Tech Stack.

And trust me, choosing your tech stack is like picking the ingredients for a gourmet sandwich. Get it right, and you've got a masterpiece. Get it wrong, and well... you're left with a soggy, unappetizing mess that's a real pain to remake.

Today, we're not just making any sandwich; we're learning how to build a technology sandwich – from the ridiculously over-engineered Dagwood to the elegantly simple gourmet slider. We'll peek at famous stacks like LAMP, MEAN, MERN, and even the fanciest custom creations. By the end, you'll be a connoisseur of tech stacks, ready to architect (or over-architect) like a seasoned pro.

So, What Exactly IS a Tech Stack? The Anatomy of Your Digital Sandwich 🥪

There's no single, universally agreed-upon definition, but think of it as all the software technologies used to build and run one application. I like to break it down into three delicious layers:

The Front-End (The "Presentation" Bread & Pretty Lettuce):
This is everything your user sees and interacts with. For web apps, this almost always means JavaScript and its powerful frameworks (React, Angular, Vue, Svelte, etc.). For mobile, you're looking at Swift/Objective-C (iOS), Kotlin/Java (Android), or cross-platform heroes like Flutter or React Native.
The Back-End (The "Engine Room" Meat & Cheese):
This is the server-side magic. It includes your server-side programming language and framework (Node.js, Python with Django/Flask, Ruby on Rails, Java with Spring, PHP with Laravel), your database (where all that precious user data lives), and the cloud infrastructure (AWS, Google Cloud, Azure) that hosts it all.
APIs (The "Special Sauce" Connecting it All & Adding Flavor):
Application Programming Interfaces are the messengers. This includes how your front-end talks to your back-end (think REST or GraphQL). Crucially, it also includes essential third-party services that you'd be crazy to build yourself: Stripe for payments, Twilio for SMS, SendGrid for emails, and so on.

A Quick Trip Down Memory Lane: The OG - LAMP Stack

Back in the digital stone age of the late '90s, building web apps was a complex, often expensive affair. Then came LAMP:

Linux (Operating System)
Apache (Web Server)
MySQL (Database)
PHP (Programming Language)

It was free, open-source, and powered a revolution, leading to giants like WordPress and Joomla. Simpler times, perhaps, but tech stacks have evolved... a lot.

The Acronym Game: Why MEAN, MERN, and MEVN Sound So Catchy

The tech world loves a good acronym. It makes you sound like you know what you're doing, even if you just picked it because it rolls off the tongue.

MEAN: MongoDB, Express.js, Angular, Node.js
MERN: MongoDB, Express.js, React, Node.js
MEVN: MongoDB, Express.js, Vue.js, Node.js

Fireship.io even cooked up FANCY: Firebase, Angular, Node.js, Cloud Functions (implied), Stripe, Express.js. (Okay, maybe I improvised a bit on the 'F' and 'C', but you get the idea!) The truth is, these catchy names rarely capture the full picture.

Let's Build a Monster! Architecting the "Next MySpace" with Maximum Overkill 🚀

Alright, let's pretend we're building the next social media behemoth. We need user authentication, a massive database for user content, and global scalability. Our guiding principle? "If it's hot, new, or adds complexity, throw it in!"

Layer 1: The Front-End Extravaganza

Language: We're targeting the web (with a side of potential mobile). So, JavaScript it is. But not just any JavaScript! We need TypeScript for that sweet, sweet type safety. Because more types = fewer bugs, right? (Spoiler: sometimes.)
UI Framework: So many choices! We'll go with React. Not necessarily because it's the best, but because it's the most popular. This means a bigger hiring pool later. Plus, React Native for that eventual mobile app. Sorry, Svelte, maybe next time.
State Management: Our app is gonna be HUGE. We need state management. Enter Redux. Everyone loves to hate it, but it allows for so much boilerplate code. And more code is always better, obviously.
Styling:
- Vanilla CSS? Please. We need Tailwind CSS for utility classes that make our HTML look like an alien artifact but let us style things "quickly."
- And because that's not enough, let's add a CSS pre-processor like Sass for more efficient styling syntax.
- Oh, and PostCSS to purge unused styles and prep for production. Can't be too careful.
Module Bundler: All that JavaScript needs to be bundled for the browser. Webpack it is! Notoriously frustrating to configure, but hey, it's popular!

Layer 2: The Back-End Behemoth

Primary Database: We need to store user data and their relationships (it's a social network!). While NoSQL (like MongoDB) is tempting for flexibility, a relational database like MySQL (the gold standard) is better for those complex relationships.
Caching Database: MySQL might get slow at scale. So, let's add Redis as an in-memory cache. Data in RAM is way faster to read!
Server-Side Runtime & Framework: As JavaScript fans, Node.js is our runtime. We'll pair it with NestJS, a framework that plays nice with TypeScript.
ORM (Object-Relational Mapper): Writing raw SQL is for peasants. We'll use TypeORM to interact with our database using JavaScript/TypeScript objects.
Web Server: To actually serve our app to the internet, we'll throw in Nginx (or Apache).
Deployment & Orchestration:
- Docker: To containerize our app, creating a standard environment.
- Kubernetes (K8s): To orchestrate our legion of Docker containers as we scale.
- Cloud Provider: Amazon Web Services (AWS). Why? For the most beautifully complex user experience, of course!
- Infrastructure as Code: We're not clicking buttons in AWS like savages. Terraform will let us define our infrastructure programmatically.
Source Code & CI/CD:
- GitHub: To host our precious code.
- GitHub Actions: For a continuous integration/continuous deployment (CI/CD) pipeline. Every push automatically tests and redeploys!

Layer 3: The API Cornucopia

Front-End to Back-End Communication: REST is old news. We're using GraphQL with Apollo Client/Server to let our front-end request exactly the data it needs.
Payments: We're not building a payment gateway. Stripe it is.
User Authentication: Definitely not rolling our own. Auth0 will handle logins, signups, and security.
Content Moderation: We don't want... unwanted images. Amazon Rekognition and its deep learning "uh-oh" detection capabilities will keep things clean.
Text Messages: How else will users get 2FA codes? Twilio to the rescue.

Phew! Look at that magnificent, over-engineered beast!

The Reality Check: Your Users Don't Give a Damn About Your Kubernetes Cluster

Here's the kicker: your end-users don't care about your tech stack. They will never know, nor should they need to know, what wizardry powers your app. They just want a good experience. If your app is slow, buggy, or hard to use because you spent six months configuring Kubernetes instead of talking to users, you'll never get to the point where you actually need Kubernetes.

"It's important to keep in mind that your end users don't care and will never know what technology you use to build the application. They just want to have a good experience."

Let's Hit Reset: The "Keep It Simple, Startup" (KISS) Approach 💋

Okay, let's throw that glorious monstrosity in the virtual garbage can and start fresh, this time with a focus on speed, simplicity, and actually shipping something.

Front-End, Simplified:

Framework: Instead of React's complexity, let's try Petite Vue. It's Vue-compatible, tiny, and you can drop it in with a <script> tag. No module bundler needed (initially)!
CSS: Bootstrap. It might be a bit "cookie-cutter," but it's arguably the fastest way to a decent-looking UI.
Mobile (If Needed Later): Ionic. It can wrap your web app in a native shell, letting you ship to iOS and Android quickly.

Back-End & APIs, Radically Simplified:

All-in-One Platform: Firebase (from Google).
- Database: Firestore (a NoSQL document database that scales beautifully).
- Authentication: Built-in user auth.
- Hosting: Static hosting for your front-end.
- All included by adding a script tag!
Server-Side Code (If You Really Need It): Firebase Cloud Functions. Write serverless functions in Node.js, Python, or Go. Deploy with a single command. No Docker, no Kubernetes, no Terraform to worry about. It scales automatically.
CI/CD: For now? Let's skip it. Unless you're deploying multiple times a day, it's probably overkill for an early-stage product.
GraphQL: Not needed. Firebase's SDKs handle data fetching just fine for most initial use cases.
Third-Party APIs: Still use Stripe for payments, etc., but integrate them directly or via Cloud Functions.

And just like that, we have the "Petite Fire" Stack (Petite Vue + Firebase). It's lean, mean, and lets you build a full-stack web application incredibly quickly.

The Moral of the Sandwich Story 🥪

Building a tech stack is a journey of choices and trade-offs. While it's fun to dream about using all the latest and greatest technologies, remember:

Complexity is a cost: It costs time, money, and mental energy.
Start simple: Get your product in front of users ASAP. You can always evolve your stack later if (and when) you achieve the scale that demands it.
Focus on user value: That's the only thing that truly matters.

So, before you build that 12-layer tech sandwich with artisanal everything, maybe start with a classic PB&J. It might just be delicious enough to get you funded.

What's in your dream tech stack? Or what's the most over-engineered setup you've ever seen? Share your thoughts in the comments below!

How Programmers Flex On Each Other

Ali Shirani — Mon, 26 May 2025 10:47:39 +0000

Okay, this is GOLD. Programmers flexing on each other? It's a tale as old as malloc. Let's turn this comedic genius into a blog post that'll have developers nodding, laughing, and maybe even feeling a little called out.

Here we go!

The Unspoken Art of the Programmer Flex: 10 Hilarious Ways We Secretly (or Not-So-Secretly) Judge Each Other 🧐

Ever been peacefully coding, minding your own //TODOs, when a colleague saunters over, glances at your screen, and drops a comment so subtly condescending it leaves you questioning your entire career?

Picture this: you're rocking your favorite VS Code theme (Synthwave '84 with Power Mode, obviously 🔥). A Staff Engineer strolls by. "Cute theme," he smirks. Before you can elaborate on its aesthetic and productivity-boosting virtues, he leans in, "You see that bug on line 234?"

"Impossible!" you declare, "100% test coverage, sir!"

He just chuckles. "Gonna pull it up in NeoVim on my Arch desktop. I'll send you a PR." Five minutes later, Slack dings. PR received. Tests passing. 469 lines of code GONE. Commit message: optimize suboptimal code. As he peels out of the parking lot in his Tesla, it hits you. You've been flexed upon. Hard.

If you're a programmer, you know the two states of being: crippling Imposter Syndrome or a God-Tier Superiority Complex. There's rarely an in-between. Today, we're diving into the latter. Let's explore 10 practical (and hilarious) ways programmers flex, so you too can achieve peak "best programmer in your own mind" status.

1. The Complexity Flex: "You Wouldn't Get It, It's Clean Code™"

The old adage says, "Any fool can write code that a computer can understand. Good programmers write code that humans can understand." But where's the fun in that?

The Move: Take a perfectly functional, simple JavaScript function.
Level Up: Slap TypeScript on it. Preach about "end-to-end type safety" like you're delivering a sermon from the Mount of Compilation.
Ascend: Refactor it into an Abstract Factory Singleton Adapter Decorator Proxy.
The Clincher: When your teammates stare blankly, sigh dramatically and mutter, "Guess you haven't read the Gang of Four. This is clean code."

The CTO (who secretly still thinks Java is a type of coffee) will be so impressed by the buzzwords, you'll get a raise. Genius!

2. The Money Flex: From Arby's to Altcoins 💰

Ah, the universal language of status. The amount of money you make is directly proportional to the value you bring... or so the LinkedIn gurus tell us.

Level 1: Junior Dev (50k/year) casually mentions their salary to old colleagues still slinging roast beef (45k/year).
Level 2: The cubicle mate who negotiated better (225k/year) silently judges Level 1.
Level 3: Their cousin at Netflix (900k/year) makes Level 2 feel like a peasant.
Level 4: The landlord, an early Uber engineer (25M net worth), posts "inspiring" threads on X about "value creation."
Boss Level: The billionaire crypto bro, who rug-pulled all the Level 1-3 flexors, posts from his yacht.

The circle of life is truly beautiful. Subscribe for more financial advice!

3. The Vim Flex: `:wq` is for Winners (Who Know How to Exit)

Using Vim doesn't just make you a programmer; it elevates you to a higher plane of existence. From this enlightened perch, you can look down upon the poor, lost souls fumbling with VS Code, IntelliJ, or (gasp) Emacs.

The Mark of a True Disciple: No mouse. Anywhere. The trackpad is covered in duct tape.
The Unspoken Truth: We've all struggled to exit Vim. But admitting it? Never. (Honestly, how do you close VS Code without clicking the 'X'?)

4. The OS Flex: "I Use Arch, BTW" 🐧

Your operating system isn't just a tool; it's a personality test.

Macintosh: "I'm rich." Add an Apple Vision Pro, and it becomes, "I'm rich AND a clown." 🤡
Ubuntu: "I'm a real developer, and I like things to mostly work." (Impresses normies).
Red Hat Enterprise Linux: "I pay IBM a lot of money. I'm a corporate baller."
The Urinal Encounter: You're minding your business. A figure appears. A knowing glance. Three whispered words: "I use Arch, btw." Instant ego deflation. Your distro feels... inadequate.
The Real Ultimate Distro: Windows. Why? It screams, "I have a life! Maybe even a girlfriend! Outside of programming!" Shocking, I know.

5. The GitHub Flex: Green Squares Are My Love Language 🟩

If your GitHub commit history doesn't look like a perfectly manicured lawn of green squares, are you even a real programmer? Do you even care about open source?

Your profile should have more badges and awards than a North Korean General. How to achieve this? By flexing on other open source projects, of course!

6. The Chainsaw PR Flex: "Optimized Your Suboptimal Code" 🔪

This one's for the Top G's of JavaScript (or any language, really).

The Strategy: Find new, small projects from young, enthusiastic developers.
The Execution: Fork their code. Remove every single line possible while ensuring all tests still pass.
The Coup de Grâce: Send a vague pull request: "Cleaned up the code to use best practices."

If done correctly, the original project will soon be abandoned. No programmer can withstand that level of flexing. We're losing them!

7. The Influencer Flex: Hot Takes & Elon Replies 🔥

Can't code? Become an influencer! It's the natural progression.

Step 1: Pay your $8 for X (formerly Twitter).
Step 2: Post outrageous hot takes that nobody could possibly agree with. "JavaScript's this keyword is perfectly intuitive." "CSS is easy." "Tabs are superior to spaces."
The Dream: If your advice is egregiously bad enough, you might even get a reply from Elon Musk himself! You can then flex about this on your YouTube channel. (Yes, that was a real tweet. Elon and I are basically best friends now.)

8. The FAANG Flex: "As An Ex-[Insert Tech Giant Here] Engineer..." 🏅

Working at a FAANG (or MANGA, or whatever acronym is cool now) company grants you a lifelong privilege: starting every sentence with, "As an ex-[Facebook/Amazon/Apple/Netflix/Google] engineer, I recommend you make X bad decision."

It's like a special club everyone wants to be in, even if they say they don't because their "moral compass is too well-calibrated." (Translation: They didn't grind LeetCode enough.) If I ever got a job at FAANG, I'd tattoo it on my forehead.

9. The Domain Hoarding Flex: My GoDaddy > Your Robinhood 🌐

Your GoDaddy account isn't just a graveyard of failed side projects; it's an investment portfolio. These domains will one day be heirlooms for your grandkids.

Best-SEO-Backlink-Tool.net? Amazing-Crypto-AI-Startup.io? MyCoolSaaSApp-v2.dev? These aren't just names; they're valuable digital real estate. Any developer would kill for such assets.

10. The Ultimate Flex: Trading Code for Cows 🧑‍🌾🐄

The programmer who blows up their meticulously curated mechanical keyboard collection, smashes their ergonomic chair, and joins the Amish is invincible.

As they milk their cow and tend their crops, their identity is no longer tied to code quality, GitHub stars, likes, followers, or even money. They look at a spiderweb, glistening with morning dew, and it reminds them of a silicon chip. They recognize the inherent intelligence permeating all of nature. Its beauty is overwhelming. They begin to cry.

In that moment, connected to all who lived and died before, they realize their own insignificance – terrifying and liberating.

And then it hits them. The spider, with its perfectly engineered web, its intricate design, its flawless execution... the spider was just flexing on them.

So, there you have it. The programmer's unofficial guide to ego management. Whether you're delivering a Chainsaw PR or simply admiring your own Arch setup, remember: we're all just trying to feel a little less like imposters in this crazy, beautiful world of code.

What's the biggest flex you've ever witnessed or perpetrated? Share your war stories in the comments below! Let the flexing continue! 👇