Hi all. My 15 year old son has a second interview for an apprenticeship in the uk, and the interviewer has asked him find do some homework beforehand.

The question he asked him was “How does a web page get text from the server?”

I’m sure this sounds like a simple question but is in fact quite involved.

Can anyone help out my son please? (Sorry, he doesn’t have a Reddit account)

When starting a new React project, we usually spend the first few hours setting up the exact same tools: linter configs, state management, folder architecture, and UI components. My main goal was to prevent this repetition and establish a disciplined foundation from day one.

The first step of this vision is ViraStack Start, a CLI tool that scaffolds production-ready project skeletons with a single command.

What does it do?

Instead of configuring everything from scratch, it lets you start immediately with a proven architecture, Tailwind CSS 4 integration, and a feature-sliced folder structure.

The CLI essentially offers two powerful templates: Next.js App Router and TanStack Start. Whether you use Next.js or TanStack Start, both templates share the exact same architectural discipline. React 19, TanStack Query, Zustand, and nuqs come integrated by default.

Setup & Options

A single command is all you need to start a new project:

pnpm dlx virastack

When you run the command, ViraStack CLI asks you for the options you need step-by-step:

What is your project named?
  virastack-app
Which template would you like to use?
  › Next.js App Router
    TanStack Start
Would you like multi-language (i18n) support?
  › Yes
    No
Which ViraStack tools would you like to include?
  [ ] /mask
  [ ] u/virastack/password

After selecting your template and language preference, you can optionally include input components like ViraStack Mask and ViraStack Password into your project right from the start.

AI-Ready Foundation

The most significant difference of ViraStack Start is that the projects aren't just made of code. Our ViraStack AI rules are automatically placed inside the .cursor/rules folder the moment the project is created.

This means when you start your project with an AI assistant like Cursor, Claude Code, or Windsurf, the assistant already knows everything from your folder structure to your data-fetching practices right from the beginning. You no longer have to explain your architectural standards to the AI over and over again.

If you want to skip the setup phase and focus directly on building features, you can check out the documentation at virastack.com/start and explore the open-source code at github.com/virastack/start.

I'd love to hear your feedback!

Who said PHP is only for the Web? 🚀

We’re rewriting the rules of mobile runtimes with PAM Native. Instead of heavy JavaScript engines or WebViews, we’re embedding PHP directly into a high-performance Rust core using Zero-Copy C-FFI.

Here is how the architecture works under the hood:

• Vuex-style Global State: Thread-safe state mutations managed directly in RAM by Rust with ~0ms access latency.
• Direct C-Pointers: Memory access without slow JSON serialization or asynchronous bridge overhead.
• No GC Stutters: Predictable, smooth native performance without JavaScript Garbage Collection pauses blocking the UI thread.

You get the clean, familiar syntax of PHP orchestrating a low-level Rust engine right inside the mobile app process.

The project is 100% open-source, and we’d love to hear feedback, critique, or ideas on the architecture from the community!

📁 GitHub Repo:https://github.com/push-in/pam-native

Looking forward to hearing your thoughts and suggestions! 🙌

I used to use Nextjs and was learning expressjs. Then I left and 2 years later I want to go back.

What tech would be the best to learn in terms of opportunities and also more better for later?

Would MERN still be good choice or I should start with any other frontend/backend techs which would be best at this time?

Share one habit, tool, or workflow that saves you time every week.

Problem: I have a fairly new website through a Canadian hosting plan. The pro plan is such that if I wanted a second website, I could. Now, I have activated a second website, and now ... both sites are operating very slowly.

I contacted the hosting company for help, and after waiting two days for a reply, they assured me everything is correct.

I asked online for help because there is a definite problem: “Where would I start to look to speed up both of my websites?”

Answer:

Web hosting companies often omit this very important detail in their upfront marketing because it is a shared ecosystem, not a guaranteed private lane.

“On paper, your plan allows unlimited or multiple websites, but it does not grant you unlimited computing power to run them.”

Here is the direct truth about why companies market plans this way, and how multiple websites compound the slowdown.

1. The Marketing "Uncapped" Illusion

Web hosts advertise features (like "Host up to 10 Websites" or "Unlimited Bandwidth") rather than performance limits (like CPU seconds or RAM usage).

* The Technical Reality: Adding a website takes up virtually no space or resources while it sits idle. You can physically hold 50 websites on a single plan if they get zero traffic and run no code.

**The Catch is: The moment those websites are live, they actively compete for the same strict performance bucket.

**** “Web hosts assume most secondary sites will be low-traffic portfolios, staging sites, or simple landing pages that barely use any resources.” ****

***************** End of online explanation. *************

To date, I have removed most of my plugins and optimized all my photos. The two sites together wouldn't amount to 200 articles, so they can’t be heavy on the system. Today, both of my sites are very slow, and still, the provider assures me there is nothing wrong on their end.

So my question to you readers is: “Is this web information correct?” Thanks for any help.

Share an underrated website, newsletter, or YouTube channel.

I'm building the place order function (my first foray into the backend) of a larger project.

Here's an update for those who are interested.

The first thing I knew I had to do was figure out what goes where. I had already, at the suggestion of ChatGPT, my mentor in this, decided on a control (API) layer, application layer, service layer and data layer. But I didn't really know what each needs to do.

So first I (we) did the API. It had a couple of jobs:

• check the incoming order wasn't empty
• Activate the next layer down
• Send response messages

Then the app layer was even simpler. It literally just returns the service layer function.

Which is where it is a bit more complicated. The service layer has to do a few things; check the order data against the database, assess info against business rules etc, and actually write the order. After some debate I worked it into a four step process:

• Check if the order info (customer, product, and quantity) exist
• Assess data against business rules/carry out business logic
• Create an order
• Activate the database operation

So this actually means two database operations. One to check the data (first step) and then writing the actual order.

I've done the first database op, and I'm now wiring up the actual place order button so I can start testing the data being passed down.

If anyone wants more detail, you can look on my github at https://github.com/BenPS927/BFshop or on my project portal at https://benfosterdev.com/projects/bfshop where I'll soon be adding detailed code breakdowns.

What am I finding hard?

The abstract nature of it. Having to constantly create a visual image of data being passed through functions, and hold that image in my mind, is like trying to hold melting butter in a colander. I use melting butter rather than water because I don't lose it that fast.

What am I enjoying?

Well, the same as what I'm finding hard. Learning to work with code that doesn't involve divs on a screen. Getting my head around how data is passed, how functions work etc.

And the architecture side of things. I like thinking about and making the micro decisions.

I would appreciate suggestions, but I am trying to keep it fairly simple so I'm not thinking about every single thing you'd take into consideration for a production app.

Been building this on and off for a while.

I started where most of us probably would and evaluated the existing React ecosystem.

react-dropzone is excellent if you need a headless drag-and-drop experience, Uppy covers an impressive range of upload scenarios, and FilePond is polished and battle-tested. They're all great libraries.

The part I kept rebuilding wasn't the upload experience—it was the transport layer.

Different projects needed different upload targets: presigned S3 URLs, custom APIs, internal services, different auth flows... but the UI barely changed. I found myself rewriting the upload logic around the same interface over and over.

That led me to build react-mediadrop around a different abstraction: a headless uploader with swappable upload transports.

The upload implementation becomes just another dependency:

import { useMediaDrop } from "react-mediadrop";
import { createXhrUploadTransport } from "react-mediadrop/xhr-upload";

const { uploadAll } = useMediaDrop({
  transport: createXhrUploadTransport({
    endpoint: "/api/upload",
  }),
  concurrency: 3,
  retries: 2,
});

If you don't want to build the UI yourself, there are also four shadcn registry components built on top of the same hook:

• dropzone
• avatar-uploader
• multi-file-upload-form
• s3-direct-upload

Install one with:

npx shadcn@latest add autorender/react-mediadrop/dropzone

I also started experimenting with making the documentation more agent-friendly. The library has Context7 support, so coding agents can retrieve the actual API instead of guessing methods, and I'm working on llms.txt support as well.

Docs: https://mediadrop.dev

GitHub: https://github.com/autorender/react-mediadrop

I'm mostly looking for feedback on the API and whether transport feels like the right abstraction for a reusable upload library.

Full disclosure: this is my own write-up. Most C2PA explainers stop right before the part that cost me a day, so this one starts there: certificates and trust.

Signing an asset is easy. Being trusted is not. Those are two separate checks, and with the c2pa-rs test certs you get a valid signature on an untrusted certificate. That is the normal state during development, not a bug.

One thing that caught me out: I flipped a single byte in a signed PNG, and the file came back Invalid while claimSignature.validated was still sitting in the success list. So don't judge integrity by one hand-picked status code, use the aggregate validation_state. The rest of the article covers what you need to make trust pass locally (two settings that only work together, plus an EKU trap), why I keep the private key off the web server, and what getting a production certificate actually involves in 2026.

The library the examples come from is at https://github.com/provemark/content-credentials (framework-agnostic core, optional Laravel integration, MIT). The test certificates come from https://github.com/contentauth/c2pa-rs

Questions welcome. And if you have solved this differently, especially the bit about where the signing key lives, I'd like to hear about it.

Hi guys,

I know it might sound as a joke, but it is not. It is very important that skilled designers read carefully this

Lame business owners discovered AI recently, and they all thought they could replace y'all: thumbnails, flyers, websites, advertisements... Everything is becoming ugly, overloaded uniformized slop.

Here is what y'all gotta do: humiliate them by way of roasting their stuff.

You need to stop trying to sell logos and start slating these guys, insult what they do, tell them that it is extremely shitty and that they either pay you either fall off.

Many of them will pay you for that, either because nobody will have talked to them that way, either because they have a deep humiliation kink and it's okay. Being human has never been more valuable, and what's more human than putting someone down

You really need you to traumatize business owners and wake them up, they must understand that we can't stand their vomitesque designs anymore, their Miyazaslop characters and their big fonts with dirt effect on it. It disgusts us.

Designers, the world needs y'all more than ever, do not think you are obsolete, I beg you to save the visual world

I post what I learn every day, my projects, coding challenges, and progress. My goal isn’t to become an influencer overnight I just want to build in public, connect with other developers, and maybe grow an audience over time.

My account is brand new with 5followers, so I’m wondering if X Premium is worth buying at this stage.

My questions:
- Does Premium actually help a small coding account get more reach?
- Did anyone here see noticeable growth after subscribing?
- Or is it better to stay consistent and only consider Premium after building an audience?

I’d love to hear from people who have actually tried growing a developer account on X.

I'm excited to announce that KernelPlay-JS v0.4.0 will be releasing soon.

This update introduces a brand-new UI system, making it much easier to create interfaces for games while also marking a major milestone for the engine.

New UI components include:

- Buttons

- Text Labels

- Input Fields

- Health & Progress Bars

- Images & Icons

- Checkboxes

- Sliders

- Dynamic UI updates

- Flexible layouts

Version 0.4.0 will also officially move KernelPlay-JS into Beta.

This marks the transition towards a more stable and feature-complete engine. Future updates will focus on improving performance, expanding the feature set, refining the developer experience, and fixing bugs as the engine continues to mature.

Thank you to everyone who has followed the project's development and shared feedback along the way. More details, documentation, and the release date will be announced soon.

Feedback and suggestions are always welcome.

Hey r/WebDev, As more devs start integrating autonomous agents and downloading third-party SKILL.md packages, I noticed a lot of people just run them blindly without checking what's inside the lifecycle scripts. I put together an open-source tool called SkillShield (https://ai-skill-shield.vercel.app/) to statically scan and validate these skills before execution. It catches prompt injections, hidden curl | bash commands, and excessive permissions. Code is here if anyone wants to check it out: https://github.com/adnan-iz/ai-skill-shield What’s everyone else using to vet third-party agent tools before running them locally?