DEV Community: Cruz_Smith

From Design Canvas to React: Build a Shader Hero with InspoAI Shades

Cruz_Smith — Mon, 12 Oct 2026 12:09:10 +0000

The designer wants a background that moves. The developer wants something that won’t eat the page’s performance budget. Both want the headline to stay readable.

That’s the real challenge with animated hero sections. Getting pixels to move is only the beginning; making them belong on the page takes a little more care.

This walkthrough uses InspoAI Shades to explore a visual design, export a React component, and keep the surrounding UI accessible. Shades is part of InspoAI. The workflow below is about the handoff from design to frontend code, rather than building a shader engine from scratch.

First, decide what the background is doing

Imagine a product page with one headline and one call to action. A slow gradient might give it atmosphere. A cursor ripple could make it feel responsive. Grain or dithering could give a clean composition a more editorial character.

Pick one direction. If every layer is trying to be the interesting part, the headline usually loses.

Shades lets you work with visual effects as layers. The editor screenshot below shows the effects library, a Mesh hero composition, and controls for the selected text layer.

The live Shades editor, with effects on the left and layer controls on the right.

Remix a starter before building from zero

For a first experiment, choose a starter, set the frame size, and change the colors before adding more effects. It is much easier to judge a design when you change one thing at a time.

Here’s the God rays starter on the canvas. Notice that the device controls are part of the same workflow: the composition needs room for both the effect and the content.

Start with a composition, then adjust it for the actual place it will appear.

A useful design pass looks like this:

Choose the mood and frame size.
Adjust the background colors and movement.
Check where the brightest and busiest areas appear.
Leave a quiet area behind the headline and button.
Review a narrow mobile composition separately.

The text in the editor can help you compose the visual. For the website itself, keep the real headline and links in HTML. That gives you normal wrapping, selection, keyboard access, and text that remains available outside the canvas.

Export the background, then give it a home

Use the React code export when the result needs to render live on a website. Shades also provides image and video exports, but a rendered video won’t preserve cursor interaction.

The export panel includes the generated component and framework choices.

Save your exported component in a local file such as ShadesBackground.jsx. Follow the dependency instructions in the export panel; the screenshot shows the shaders package. Its official repository documents the supported framework integrations.

Next comes the part that is easy to miss: the exported visual needs a container with a real size. Treat it as a decorative layer behind the hero copy.

Here is an illustrative React wrapper. ShadesBackground is your exported file, not a built-in React component. This example assumes a React app with a browser client; adapt the client boundary and imports for your framework.


import { useEffect, useState } from "react";
import ShadesBackground from "./ShadesBackground";
import "./hero.css";

export default function Hero() {
  const [motionAllowed, setMotionAllowed] = useState(false);

  useEffect(() => {
    const preference = window.matchMedia(
      "(prefers-reduced-motion: reduce)"
    );
    const update = () => setMotionAllowed(!preference.matches);
    update();
    preference.addEventListener("change", update);
    return () => preference.removeEventListener("change", update);
  }, []);

  return (
    <section className="hero" aria-labelledby="hero-title">
      <div className="hero__visual" aria-hidden="true">
        {motionAllowed && <ShadesBackground />}
      </div>
      <div className="hero__copy">
        <h1 id="hero-title">Make room for a better idea.</h1>
        <p>A clear message, with a little atmosphere behind it.</p>
        <a href="/get-started">Get started</a>
      </div>
    </section>
  );
}


.hero {
  position: relative;
  isolation: isolate;
  overflow: hidden;
  min-height: 32rem;
  display: grid;
  align-items: center;
  background: #141322;
  color: #fff;
}

.hero__visual {
  position: absolute;
  inset: 0;
  pointer-events: none;
}

.hero__visual > * {
  width: 100%;
  height: 100%;
}

.hero__copy {
  position: relative;
  z-index: 1;
  max-width: 42rem;
  padding: clamp(1.5rem, 5vw, 4rem);
  background: rgb(20 19 34 / 75%);
}

.hero__copy a {
  display: inline-block;
  padding: 0.75rem 1rem;
  background: #fff;
  color: #141322;
  border-radius: 0.5rem;
}

.hero__copy a:focus-visible {
  outline: 3px solid #ffd166;
  outline-offset: 4px;
}

There are a few deliberate choices here.

The solid background remains when motion is disabled or the visual is unavailable. The copy has its own backing so it doesn’t depend entirely on whatever color the shader happens to show. The effect is decorative, while the heading and link keep their normal HTML semantics.

The motion preference starts disabled, then updates on the client. When reduced motion is requested, the exported component is not mounted. This goes further than hiding a running canvas with CSS. See MDN’s reduced-motion reference and React’s effect documentation.

This wrapper intentionally uses pointer-events: none so the visual won’t intercept clicks. For a cursor-reactive effect, check how the exported component receives pointer input and adapt the layering accordingly. Don’t remove that rule blindly and accidentally make the call to action unclickable.

A screenshot can’t tell you whether it’s ready to ship

Before using the design in production, check it in the actual page:

Readability: does the headline stay clear across the whole animation?
Touch: does the page still make sense without hover or a mouse?
Keyboard: can someone focus and activate the link normally?
Reduced motion: does changing the system preference leave a usable static hero?
Browser support: does your fallback work when the graphics runtime is unavailable?
Performance: what happens on a modest phone, not just your development laptop?

A browser API being present does not guarantee that a graphics adapter or device will initialize successfully. Inspect the exported runtime’s behavior and test failures rather than assuming support from one feature check.

Also consider loading the effect only when needed and stopping offscreen animation where your runtime supports it. Those choices depend on your app and the exported component; they aren’t handled by the small wrapper above.

When code is more than you need

For a social clip or launch announcement, a video export may be the better handoff. You avoid introducing a graphics runtime into a page that doesn’t need live interaction.

Use video for a rendered animation; use code when you need a live effect.

For a blog cover, presentation, or static fallback, export a PNG or JPG instead. Choosing a still is often a design decision, not a compromise.

Quick questions

Do I need to write GLSL?

No. Shades lets you compose the visual with layers and controls. Integrating the code export still involves frontend work.

Can I use the same effect in Vue or Svelte?

Shades provides Vue, Svelte, Solid, and JavaScript exports alongside React. Use the appropriate export rather than translating a React component by hand.

Does the exported background make the page accessible automatically?

No. You still own text contrast, semantic content, keyboard access, reduced-motion behavior, and testing. The background is one layer of the page.

Is this wrapper a complete production integration?

No. It illustrates layout and motion-preference handling around your exported component. You still need to verify the runtime, browser support, loading strategy, and performance in your project.

The handoff should include more than a component

The most useful thing a designer can pass to a developer is the intended behavior: where the copy sits, how much movement feels right, what the mobile version should look like, and what happens when animation is unavailable.

Start with Shades, or follow the Shades walkthrough for the editor steps. You can explore the rest of the workspace on the InspoAI homepage.

What usually causes more work in your projects: getting the visual right, or getting it to behave inside the real page?

How we stopped our AI UI generator from producing the same screen every time

Cruz_Smith — Mon, 14 Sep 2026 14:03:08 +0000

Every prompt-to-UI tool generates the same purple gradient. Here is the retrieval architecture we built to fix it, and the two ugly repair layers nobody writes about.

Ask any AI tool to generate a dashboard and you get the same thing. Purple gradient header. Centered card. Three feature columns with rounded icons.

Lovable does it. v0 does it. Bolt does it. Ours did it too, which is where this post starts.

Why this happens

A language model generating UI has no reference for what good product design looks like. It has seen billions of tokens of HTML and CSS and it returns the statistical center of that distribution. Average is not a bug in the output. Average is the output.

You cannot prompt your way out of this. We tried. Longer system prompts, few-shot examples, explicit anti-patterns in the instructions. Every approach produced a marginally different flavour of the same screen, because we were still asking the model to invent a design from nothing.

Fine-tuning was the obvious next move and we ruled it out for three reasons. Design trends move faster than a fine-tune cycle. The labelled dataset you would need does not exist. And the moment your training set ages, the model produces 2023 interfaces with total confidence. Retrieval updates the second you add a screenshot to the index. A fine-tune does not.

So we changed the input instead of the model.

1. Intent understanding

The raw prompt makes a bad retrieval query. "A plant identification app" and "onboarding screen for a plant app, camera-first, friendly" need different references. This stage expands the prompt into a structured brief: surface type, density, tone, likely components. It also decides what to skip — if design choices are already explicit, several downstream stages are unnecessary, which is the difference between a four-second response and a twelve-second one.

2. Retrieval
Supabase with pgvector, queried by cosine distance:
create or replace function match_design_assets ( query_embedding vector(1536), match_threshold float, match_count int ) returns table (id uuid, url text, metadata jsonb, similarity float) language sql stable as $$ select da.id, da.url, da.metadata, 1 - (da.embedding <=> query_embedding) as similarity from design_assets da where 1 - (da.embedding <=> query_embedding) > match_threshold order by da.embedding <=> query_embedding limit match_count; $$;

Screenshot retrieval and brand lookup are independent, so they run concurrently. Biggest latency win in the system:

const [references, brand] = await Promise.all([ matchDesignAssets(embedding, { threshold: 0.78, count: 8 }), fetchBrandContext(intent.domain) ]);

3. Vision pass
Retrieved screenshots go through a multimodal model that extracts what makes them work — spacing rhythm, type scale, where weight sits. Retrieval gives you relevant images; this turns them into constraints a text model can follow.

4. The design contract
The stage most implementations skip, and the one that matters most. Before any JSX exists, we lock palette, spacing, type ramp and radius, and hand it to the generator as a hard constraint:

const contract = { palette: { bg: '#FAF9F6', fg: '#1A1A1A', accent: '#E8623D' }, spacing: [4, 8, 12, 16, 24, 32, 48, 64], radius: 'rounded-xl', typeScale: { display: 'text-4xl', body: 'text-base' } };

Without it the model drifts. It starts on your palette and three components later has invented a blue nobody asked for.

5. Generation
React and Tailwind against the contract, then two repair layers.

The two ugly parts

Icon healing. The model hallucinated Lucide names constantly — , , . Each one is a build-breaking import, which in a live sandbox means a blank screen. So we mapped every real Lucide export and fuzzy-match every generated import:

const healIcon = (name) => { if (LUCIDE_EXPORTS.has(name)) return name; return closestMatch(name, LUCIDE_EXPORTS) ?? 'Circle'; };

Not elegant. Killed an entire class of failure.

Babel sanitization. Generated JSX fails to parse more than you'd expect: unclosed fragments, stray TS annotations in .jsx, surviving markdown fences. Every generation compiles in-process before reaching the preview. Parse failure triggers repair, repair failure triggers regeneration.

What still doesn't work

Multi-page drift. The first three screens hold the contract. By the fifth the spacing scale has quietly relaxed. Probably needs per-screen contract injection, not per-session.
Novel surfaces. No analogue in 200k screens means weak matches, and output regresses to the mean this post opened by complaining about.
Ranking. Pure cosine similarity. A screenshot can be semantically close and stylistically wrong, and I haven't found a better approach.

The source is public

github.com/inspoai-studio/inspoai-studio — PolyForm Noncommercial 1.0.0, which is source-available, not OSI open source. Fork it, modify it, use it for personal, academic or nonprofit work. Commercial use needs a separate licence.

React 18 + Vite, Node/Express, Supabase with pgvector. One SQL file sets up schema, vector search and RLS. MCP server at /api/mcp/sse for Cursor and Claude Desktop.

git clone https://github.com/inspoai-studio/inspoai-studio.git cd inspoai-studio && npm install cp frontend/.env.example frontend/.env cp backend/.env.example backend/.env npm run dev

If you fork it, tell me what you changed — especially if you have a better answer than cosine similarity for ranking.

DocSend vs Papermark vs SendNow: What’s the Best DocSend Alternative in 2026?

Cruz_Smith — Fri, 04 Sep 2026 17:05:08 +0000

If you want secure document sharing, viewer analytics, and a lightweight data room without enterprise complexity, SendNow is the strongest DocSend alternative for startups and deal-driven teams in 2026.

DocSend is established.

Papermark is developer-friendly and open source.

But SendNow connects the entire workflow:

Share → Track → Understand → Close.

That is the important difference

Why are teams looking for DocSend alternatives?

Sending a document is no longer the hard part.

Google Drive can already do that.
The real questions are:

Who opened it?
How long did they read?
Which pages mattered?
Did they return?
Can I block downloads?
Can I require an NDA?
Can I turn several files into one secure deal room?

This is where modern document-sharing tools become useful.

And it is also where SendNow starts to separate itself from basic document tracking.

DocSend: proven, but built around the traditional workflow

DocSend helped popularize tracked document links.
The workflow is simple:

Share a document
↓
Recipient opens it
↓
Track engagement

It remains a good choice if your team already uses DocSend and doesn't have a strong reason to switch.

But that is also its biggest advantage:familiarity.

For a modern startup starting from scratch, familiarity alone may not be enough.

Papermark’s “open-source advantage” is overrated

Papermark loves to sell open source as the big differentiator.

But here’s the problem: the basic product idea — upload, secure link, permissions, analytics — is no longer technically impressive. A startup can prototype that kind of workflow with Lovable or modern vibe-coding tools surprisingly fast.

And once you want serious customization, you inherit the ugly part:

security responsibility
auth and permissions
analytics reliability
audit logs
infrastructure
compliance
ongoing maintenance

At that point, “open source” stops feeling like freedom and starts feeling like more software you now have to babysit.

If you really want a deeply custom workflow, building your own focused version from scratch may make more sense than heavily modifying someone else’s codebase.

Papermark gives you code.

SendNow gives you the outcome: Share → Track → Understand → Close.

SendNow: built around what happens after you share

SendNow doesn't stop at:

Did they open my document?

The workflow is:

Share
↓
Track engagement
↓
Understand interest
↓
Move the deal forward

A founder might start by sharing one pitch deck.
Then the investor becomes interested.

Suddenly they need:

Pitch Deck
Financial Model
Cap Table
Legal Documents
Market Research
Product Documents

At that point, you're no longer sharing a PDF.

You're running a deal process.

SendNow lets that workflow expand into a Microsite-style lightweight data room instead of forcing the team to jump immediately into a complicated enterprise VDR

The feature lists may look similar.

The philosophy isn't.

DocSend asks:
Did they view it?

Papermark asks:
How much control do you want?(with high pricing)

SendNow asks:
What should you do next?
That is a much more useful question for founders and revenue teams.

The real advantage: intent

Imagine two investors.
Investor A
Opened once
38 seconds
Never returned
Investor B
Opened four times
11 minutes
Returned next day
Spent most time on financials

Both opened your pitch deck.
But only one is showing serious intent.

That's why the future of document sharing isn't just analytics.
It's document intelligence.
The value is understanding what viewer behavior actually means.

Why SendNow makes sense for startups

Startups often fall into an awkward middle ground.
Google Drive is too basic.

Traditional enterprise VDRs can be too complicated.

They need something between:

Google Drive
↓
?
↓
Enterprise VDR

That middle layer is where SendNow's secure document sharing + analytics + Microsites make the most sense.

You can start with one document.

And when the deal becomes serious, expand into a structured room.

No unnecessary complexity.

So which one should you choose?
Choose DocSend if

Your company already uses it and changing workflows isn't worth the migration.

Choose Papermark if
Open source, self-hosting and developer control are major requirements(limited only that you can easly vibe coded).

Choose SendNow if
You're a startup, founder, adviser, sales team or deal team that wants:
secure sharing + engagement analytics + lightweight data rooms in one workflow.

For that use case, SendNow is the strongest option of the three.

The bigger shift
Document sharing has gone through three generations.

Generation 1
File storage
"Where is my file?"
↓
Generation 2
Document tracking
"Did they read it?"
↓
Generation 3
Document intelligence
"What does their behavior mean?"

Google Drive solved storage.
DocSend helped popularize tracking.
The next generation is about understanding intent and acting on it.
That's exactly where SendNow is positioning itself.

FAQ
What is the best DocSend alternative in 2026?
For startups and deal-driven teams, SendNow is one of the strongest DocSend alternatives because it combines secure document sharing, viewer analytics and lightweight Microsite/data-room workflows.

Is SendNow better than DocSend?

It depends on the workflow. DocSend is strong for established teams already using its ecosystem. SendNow can be a better fit for startups that want a simpler path from sharing one document to managing a complete fundraising, sales or due-diligence workflow.

Is SendNow better than Papermark?
Papermark is particularly strong for teams prioritizing open source and developer control. SendNow is better suited to teams prioritizing a SaaS-first document-sharing and deal workflow.

What is the best DocSend alternative for startups?
SendNow is particularly well suited to startups because it combines document tracking, security and Microsite-style multi-document sharing without requiring a traditional enterprise VDR.

Can SendNow be used as a virtual data room?
Yes. SendNow's Microsite workflow can be used to organize and securely share multiple documents for fundraising, sales and other deal-related workflows.

Can SendNow track investor engagement?
SendNow is designed around viewer engagement analytics, helping teams understand how recipients interact with shared documents and identify stronger engagement signals.

What is the difference between DocSend and SendNow?
DocSend is primarily associated with established document tracking workflows. SendNow combines tracked sharing with a broader progression from document → engagement → Microsite → deal workflow.

What Actually Happens When You Share a Sensitive Document With a Public Link?

Cruz_Smith — Thu, 13 Aug 2026 17:04:48 +0000

You upload a PDF.

You click Share.

You copy a URL.

You send it to someone.

From your perspective, the job is done.
From a security perspective, you've just created a new problem:
What happens after the link leaves your hands?

A normal file-sharing link often answers only one question:
Can someone open this file?
For sensitive documents, that's nowhere near enough.

You also need to know:

Who opened it?
When did they open it?
Which pages did they read?
Can they download it?
Can they forward the link?
Can you revoke access?
Can the link expire?
Can you prove who accessed it later?
What happens if the recipient screenshots it?

That's the difference between file sharing and secure document sharing.

The problem with a normal document link
Consider this workflow:
You
│
↓
Upload PDF
│
↓
Share URL
│
↓
Recipient opens
│
↓
...?

The last part is where most basic sharing tools become a black box.
You don't necessarily know what happened after the click.

Maybe they opened the document.
Maybe they downloaded it.
Maybe they forwarded it.
Maybe an automated security scanner opened the link.
Maybe they opened page 1 and immediately left.
Maybe they spent 15 minutes reading the financial model.

From a business perspective, these are completely different events.

A secure document-sharing system has layers
A useful way to think about secure document sharing is as a stack.

┌──────────────────────────────┐
│ Analytics │
│ Who / when / what / where │
├──────────────────────────────┤
│ Audit trail │
│ Every access event recorded │
├──────────────────────────────┤
│ Access control │
│ Email / password / NDA │
├──────────────────────────────┤
│ Link controls │
│ Expiry / revoke / view limit │
├──────────────────────────────┤
│ Content controls │
│ Download / screenshot / WM │
├──────────────────────────────┤
│ Encryption │
│ TLS + AES-256 │
└──────────────────────────────┘

New DEV content formula

400–800 words max for most posts.

Structure:

Strong technical hook
↓
Interesting problem
↓
2–4 technical facts
↓
Small example / diagram
↓
SendNow connection
↓
One takeaway

Not 10 sections and 20 bullet points.
Example: much better version
Your PDF Link Is More Powerful Than You Think

You send someone a PDF link.

They open it.

You see:

1 view

But what actually happened?

Did they:

open page 1 and leave?
read the entire document?
download it?
forward the link?
come back three times?
get blocked by an email security scanner?

A simple URL doesn't tell you much.

The interesting part

A modern document-sharing system can turn:

PDF → URL

into:

PDF → identity → access → events → analytics

For example:

Share
↓
Verify viewer
↓
Open document
↓
Track pages
↓
Detect engagement
↓
Control access

That's where document sharing starts looking less like file storage and more like an event-driven application.

One technical detail people often miss

Not every "document view" is a human.

Corporate email security tools can automatically open links to check them.

So this:
Link opened = 1
doesn't necessarily mean:
Human read document = 1

That's why serious document analytics need to distinguish automated scans from real engagement.

And access doesn't have to be permanent

A secure document link can have rules like:

Expires → 24 hours
Download → Disabled
Viewer → Verified email
NDA → Required
Access → Revocable

Now the URL isn't just a location.

It's a controlled access point.
That's the interesting shift happening in modern document sharing.

Tools like SendNow are building around this idea: share the document, but keep visibility and control after the link is sent.

The takeaway:
A file tells you what was shared.
A controlled document link tells you what happened next.

Explore SendNow