DEV Community: 高赫阳

Building RepostViewer: A Focused Web Tool for Public TikTok Reposts and Comments

高赫阳 — Fri, 16 Oct 2026 08:50:57 +0000

I have been building RepostViewer, a small web tool focused on a narrow question: how can someone inspect publicly available TikTok reposts and comments without turning a quick lookup into a complicated workflow?
Start with a specific task
People arrive with different questions. One person wants to see recent public reposts associated with a TikTok profile. Another wants to read comments on a public video. These are related activities, but they need different inputs. The repost tool starts with a public username; the comment tool starts with a public TikTok video URL.
Keeping those paths separate makes the interface easier to understand. A visitor should know what to paste, what to expect, and why a result may be unavailable.
Make the first interaction simple
For basic browsing, the intended experience does not require signing in to TikTok. The page presents a direct input and returns the public information the upstream service can provide. The comment interface displays available comment text, authors, timestamps, likes, and reply counts when those fields are present. Additional comments are fetched only when a visitor chooses to load more.
There is a useful engineering lesson here: pagination is a product decision as much as an API decision. Loading everything by default increases latency and upstream requests. An explicit “Load More” action makes the cost and waiting time proportional to what a visitor actually wants to read.
Treat public data boundaries as part of the product
A public-data viewer should not imply that it can access private accounts, hidden posts, deleted material, or every historical repost. Availability changes, and some results may be incomplete. RepostViewer is designed around these limitations rather than promising unrestricted access.
The implementation also keeps upstream API credentials on the server. Video URLs are validated before being resolved, including checks around short-link redirects. Those are not flashy features, but they matter whenever a tool accepts user-provided URLs.
Build only what the workflow needs
The application uses Next.js and TypeScript, with server-side routes for data access. The focus has been on a clear result view, understandable errors, responsive layouts, and search-friendly explanatory pages. I deliberately left out unrelated features such as video downloads, account monitoring, and bulk automation.
The next step is learning from real usage: which lookups people try, whether they use pagination, and what information they actually need. That evidence should drive future features rather than a long speculative roadmap.
If you work on focused utilities, I would be interested in how you decide what not to build.
Project: https://repostviewer.com
RepostViewer is an independent tool and is not affiliated with TikTok or ByteDance.

I Built ScanInsta: A Browser-Based Instagram Profile Viewer for Public Research

高赫阳 — Sun, 27 Sep 2026 10:43:57 +0000

Instagram profiles contain a surprising amount of useful public context: a bio, verification status, follower and following counts, post volume, and recent public content. The problem is that checking this information repeatedly can be awkward when you are doing creator research, competitor screening, or brand-partnership due diligence.

That is why I built ScanInsta, a browser-based Instagram Profile Viewer focused on public information only.

The idea is intentionally simple: enter a public Instagram username and get a clean profile snapshot without logging into Instagram, sharing a password, or installing a browser extension. ScanInsta is designed for people who need fast context rather than another social media dashboard.

What ScanInsta shows

For a public profile, ScanInsta can display the profile photo, display name, bio, verification status, follower count, following count, post count, and recent public posts when they are available. The goal is not to assign a mysterious score to an account. These are background signals that users can interpret in context.

That distinction matters. A large follower count does not automatically mean an account is influential, trustworthy, or a good fit for a campaign. A post count does not tell you whether the content is high quality. ScanInsta simply makes the public profile information easier to review in one place.

Why public data only

I wanted the product boundary to be clear from the beginning. ScanInsta does not claim to reveal private profiles, private followers, private posts, or hidden account information. If Instagram marks something as private, ScanInsta does not try to work around that restriction.

It also does not ask for an Instagram password. For the free workflow, there is no Instagram login requirement and nothing to install.

Who it is for

The most obvious use case is influencer vetting. A brand can quickly review a creator's public profile before deciding whether it is worth doing deeper research or reaching out. Agencies can use the same workflow when screening multiple potential partners.

Competitor research is another use case. Public profile metrics and recent posts can provide a fast snapshot of how actively a competitor is publishing and what kind of content it is putting in front of its audience.

Journalists and PR teams can also use a public profile viewer to collect basic context before outreach. The point is not to replace proper research, but to reduce friction in the first pass.

The stack

ScanInsta is built with Next.js and TypeScript and is deployed as a web application, so the main product experience runs in the browser. I use server-side API routes rather than exposing upstream data-provider logic directly to the client. Redis-based caching and rate limits help control repeated requests, and Cloudflare Turnstile is used as part of the anti-abuse flow.

One of the engineering goals was to keep the initial interaction simple. A visitor should be able to try the product before being pushed into an account-creation flow. The free tier currently supports a small number of daily profile lookups, while higher-volume features such as batch checks, CSV export, profile tracking, and API access are part of the broader product plan.

What I learned

Building a tool around a familiar platform is mostly an exercise in boundaries and reliability. It is tempting to add more promises to make a product sound powerful, but social-data tools are much easier to understand when they are explicit about what they can and cannot access.

For ScanInsta, the product promise is deliberately narrow: help users review publicly available Instagram profile information in a clean browser interface.

The project is available at https://scaninsta.com/.

I am continuing to improve the lookup workflow, caching, rate limiting, and higher-volume research features. If you work in creator research, influencer marketing, competitive analysis, or social media tooling, I would be interested in hearing which public-profile fields are actually useful in your workflow.

I Built a No-Login Instagram Follower Export Tool with Next.js

高赫阳 — Sat, 19 Sep 2026 07:47:51 +0000

If you have ever tried to move an Instagram follower list into a spreadsheet, you know how awkward the workflow can be.

A lot of existing tools require a browser extension, an Instagram login, session cookies, or a complicated automation setup.

I wanted something simpler.

So I built IG Follower Exporter, a browser-based tool for downloading publicly available Instagram follower records as CSV.

👉 https://igfollowerexporter.com

What it does

The workflow is intentionally simple:

Enter a public Instagram username
Check the account
Start the follower retrieval
Download the available follower records as CSV

No Instagram login is required.

No password is required.

There is nothing to install.

The tool is designed for use cases such as:

competitor audience research
influencer research
creator discovery
social media analysis
spreadsheet-based audience research

Why I built it

I kept seeing the same friction with Instagram research tools.

Some require installing a Chrome extension. Others require connecting an Instagram account or supplying session information.

For a simple task like turning public follower information into a spreadsheet, that felt unnecessarily complicated.

My goal was to make the workflow feel more like a normal web utility:

username → results → CSV

The technical stack

The application is built with:

Next.js
React
TypeScript
Tailwind CSS
Supabase
Vercel
Cloudflare Turnstile
SocialCrawl for Instagram data access

The most interesting engineering problem was actually not generating the CSV.

It was building a durable export process.

Large follower lists require pagination and multiple upstream requests, so a single long-running HTTP request is not reliable enough.

The current architecture uses resumable export jobs with persisted checkpoints. If an export takes multiple batches, the job can continue without starting from the beginning.

I also added:

row-based usage accounting
duplicate protection
resumable pagination
server-side API credentials
Turnstile abuse protection
CSV generation
payment entitlements

Free to try

New users can currently retrieve up to 100 follower rows for free.

The goal of the free tier is simply to let someone verify that the tool works for their use case before paying.

If you work with Instagram audience data, I would be interested in hearing what fields or workflows would make this more useful.

Try it here:

https://igfollowerexporter.com

I Built Socionar: An AI Bio Generator and Brat-Style Creator Tool

高赫阳 — Wed, 16 Sep 2026 06:07:34 +0000

I’ve been building Socionar, a small collection of tools for people who want to improve how they present themselves online.
The main tool is an AI Bio Generator that uses both text and uploaded photos to create personalized Instagram and TikTok bio ideas. Instead of only generating generic one-liners, it can use visual context, interests, and style to make the results feel more relevant to the creator.
I also added a Brat Generator inspired by the recognizable visual style around Charli XCX’s Brat. You can create custom text-based Brat-style visuals directly in the browser and export them for sharing.
The goal is to keep the tools simple: open the page, create something useful, and move on without unnecessary setup.
https://socionar.com/
I’m continuing to improve the project, so feedback on the tools and user experience is welcome.

How I Built an AI Room Design Tool That Turns One Photo Into a Before-and-After Video

高赫阳 — Wed, 09 Sep 2026 14:12:23 +0000

AI room design tools are everywhere now, but most of them stop at one thing:

Upload a room photo → generate another room photo.

I wanted to build something slightly different.

Instead of only showing a redesigned image, I wanted users to see the transformation as a short before-and-after video.

That idea became RoomFacelift.

👉 https://roomfacelift.com

What RoomFacelift does

The workflow is simple:

Upload a photo of your room
Choose the room type
Pick an interior design style
Decide how much of the room can change
Generate a redesigned version
Turn the original and redesigned images into a transformation video

The goal is to make AI room design feel less like generating a random image and more like visualizing an actual renovation.

Keeping the original room recognizable

One of the hardest problems was not image generation itself.

It was preservation.

AI models often change things users do not want changed:

camera angle
windows
doors
TVs
wall geometry
visible floor area
room proportions

For a room redesign tool, that can make the result feel fake.

So I added two design modes.

Keep Layout

This mode tries to preserve:

viewpoint
camera height
framing
perspective
room geometry
major architectural elements

The AI mainly changes furniture, materials, lighting, decoration, and interior style.

Reimagine Space

This mode gives the model more freedom to redesign the room while still trying to keep the same camera position and overall identity.

That distinction turned out to be important because different users want very different levels of transformation.

Interior styles

RoomFacelift currently supports styles such as:

Modern
Scandinavian
Japandi
Mid-century Modern
Industrial
Bohemian
Luxury
French Country
Minimalist
Art Deco
Coastal
Farmhouse
Mediterranean
Contemporary
Traditional

Instead of relying only on the style name, each style is backed by a more structured design recipe.

That helps make the generated results more consistent.

The technical stack

The application is built with:

Next.js
TypeScript
Supabase
fal.ai
Cloud storage
Google Cloud Run
FFmpeg
Waffo for payments

The basic generation pipeline looks like this:


text
User photo
   ↓
Private storage
   ↓
AI redesigned image
   ↓
Before + After frames
   ↓
Image-to-video generation
   ↓
Watermark processing
   ↓
Final transformation video

AudioCraft – AI stem splitter and vocal remover with a browser-based mixer

高赫阳 — Sun, 23 Aug 2026 10:54:55 +0000

I’ve been building AudioCraft as a focused AI music tool for separating songs into useful stems.
The main workflow is simple:

upload MP3, WAV, FLAC, or M4A
separate the track into vocals, drums, bass, and other instruments
preview the stems
mute, solo, and adjust individual tracks
create an instrumental version
download individual stems or all stems together AI Stem Splitter https://audiocraft.app/ AudioCraft uses AI source separation rather than simple frequency filtering. It is useful for instrument practice, remixing, karaoke, arrangement analysis, and extracting vocals or backing tracks. The result page includes a synchronized stem mixer, so users can solo the bass, mute the vocals, or compare different parts of the arrangement without opening a DAW. Temporary Audio Processing Privacy: https://audiocraft.app/privacy Uploaded source audio is temporarily stored so the AI service can process it, then AudioCraft automatically attempts to delete the original file after processing finishes. Generated stem links are temporary, so users should download results they want to keep. Product Analytics and Feedback AudioCraft tracks product-level events such as uploads, successful separations, downloads, and failures, while avoiding file names, audio URLs, and media contents in analytics. Users can also rate the separation result as good or needing improvement, which should help improve future model and product decisions. Where I want to take AudioCraft next https://audiocraft.app/about The next direction is AI music transcription. The idea is to use stem separation first, then turn cleaner vocals, bass, or instrument stems into things like:
MIDI
sheet music
melody transcription
chord detection
BPM and key analysis The longer-term goal is for AudioCraft to become a small AI music-analysis toolkit rather than just another vocal remover.

Criei um compressor de vídeo online pensado para usuários em português

高赫阳 — Fri, 14 Aug 2026 02:04:42 +0000

Estou construindo o Vidoro, uma ferramenta simples para compactar vídeos online.
Percebi que muitas ferramentas de vídeo são feitas principalmente para usuários de inglês, enquanto usuários de português (especialmente no Brasil) ainda têm poucas opções bem localizadas.
Por isso criei uma versão em português para ajudar pessoas a reduzir o tamanho dos vídeos antes de enviar pelo WhatsApp ou redes sociais.
Ainda estou melhorando a ferramenta e adoraria receber feedback de outros criadores.
https://vidoro.io/pt/comprimir-video-online

I Built Vidoro — A Browser-First Toolkit for Video Compression and Media Conversion

高赫阳 — Thu, 13 Aug 2026 07:32:04 +0000

Hi everyone!

I’ve been building a side project called Vidoro — a collection of simple online media tools focused on video compression, format conversion, privacy, and practical everyday workflows.

The idea is straightforward:

Choose a file → process it → download the result.

No complicated editing interface, no unnecessary account creation, and for tools that can reasonably run in the browser, no file upload to a remote server.

Vidoro currently includes a homepage, two versions of the video compressor, and a MOV-to-MP3 converter. I’m gradually turning it into a larger collection of focused media utilities.

💡 Why I Built It

A lot of online media tools technically work, but the experience often feels heavier than the task itself.

For something as simple as reducing the size of a video or extracting audio, users may have to:

upload a large file to a remote server
wait for the upload to finish before processing even starts
create an account
navigate several configuration screens
deal with watermarks or usage restrictions
wonder what happens to the uploaded file afterward

I wanted Vidoro to feel more like a local utility that happens to run in a browser.

Whenever browser-side processing makes sense, the file stays on the user’s device and FFmpeg runs through WebAssembly.

For heavier or smarter workflows, Vidoro can also use a backend processing pipeline, but I try to keep that distinction clear to the user.

🌐 Vidoro Homepage

👉 https://vidoro.io/

The homepage is the central entry point for the project.

Instead of building every tool as an isolated website, I’m putting them under one product and one design system.

The goal is for Vidoro to eventually become a toolbox for common media tasks such as:

video compression
audio extraction
video conversion
image conversion
video-to-GIF
audio processing
other lightweight media utilities

The homepage is intentionally simple.

Rather than showing dozens of settings or categories immediately, it introduces the available tools and lets users go directly to the task they need.

🎬 Compress Video Online — English

👉 https://vidoro.io/compress-video-online/

This is the English, privacy-focused version of Vidoro’s video compressor.

The main idea behind this page is:

compress the video directly in the browser without uploading it to a server.

The workflow is:

Choose a video
Select a compression level
Let FFmpeg WASM process the video locally
Download the compressed MP4

The current compression options are intentionally simple:

High Quality
Balanced
Maximum Compression

I didn’t want users to have to understand CRF values, encoding presets, audio bitrates, or other FFmpeg parameters just to reduce a file size.

Under the hood, the browser version currently uses FFmpeg with H.264 video and AAC audio and generates an MP4 output.

The page supports common formats such as MP4, MOV, AVI, MKV, WebM and other formats already handled by the converter.

One of the main goals of this version is privacy.

For the normal compression workflow:

the video stays on the device
there is no server upload
there is no account requirement
there is no watermark

This also means the performance depends heavily on the user’s device.

A powerful desktop can process videos reasonably well, while very large files on a phone can obviously be more challenging.

That tradeoff is something I’ve found interesting while building the project.

🇧🇷 Comprimir Vídeo Online — Portuguese

👉 https://vidoro.io/pt/comprimir-video-online/

The Portuguese version is currently more advanced than the English version.

It contains the same local FFmpeg WASM compression workflow, but it also includes a smart compression mode.

This mode is aimed at a problem I noticed while working on video compression:

Most users don’t actually know what compression settings they need.

They don’t think in terms of:

bitrate
codec
CRF
frame rate
resolution

They think in terms of:

“I need to send this on WhatsApp.”

“I need a smaller attachment for email.”

“I want to save storage space.”

So the smart compression mode analyzes information about the uploaded video and allows the user to choose a target use case such as:

WhatsApp
Instagram
Email
Website upload
Storage saving

Vidoro then recommends a compression profile.

The analysis can include information such as:

resolution
duration
codec
FPS
file size
bitrate where available

The system then recommends settings such as:

target codec
CRF
target resolution
FPS
estimated output size

I also spent some time improving the output-size estimation.

An early version could predict something like:

4.7 MB → 700 KB

while FFmpeg actually produced something closer to:

4.7 MB → 2.1 MB

That was obviously too optimistic.

The estimation system is now more conservative and takes more properties of the source video into account.

In one of my later tests:

Original: 329,498 bytes
Predicted: 166,045 bytes
Actual output: 159,576 bytes
Reduction: 51.6%

That was much closer to the real output.

🤖 AI / Smart Compression Architecture

One important design choice is that the smart compression system does not require an AI API to work.

It uses a hybrid approach.

The basic pipeline can work with:

ffprobe → video metadata → deterministic compression profiles

So even without an OpenAI API key, it can still analyze the video and generate recommendations.

An optional LLM layer can be used for richer recommendations, but the core functionality does not depend on it.

I like this architecture because I don’t want an “AI feature” to stop working just because an external API is unavailable.

The deterministic system remains the fallback.

🎵 MOV to MP3 Converter

👉 https://vidoro.io/mov-to-mp3-converter/

The MOV-to-MP3 converter is much simpler, and that is intentional.

Its job is just:

take a MOV video and extract the audio as MP3.

The entire conversion happens inside the browser with ffmpeg.wasm.

The MOV file is not uploaded to Vidoro.

The workflow is:

Select or drag in a MOV file
Choose MP3 quality
Convert it locally
Download the MP3

This can be useful for things like:

extracting audio from iPhone videos
interviews
lectures
voice recordings
video podcasts
saved clips
music or audio recordings stored inside MOV files

The default configuration is designed to be simple rather than expose every FFmpeg audio option.

For this kind of task, I think that is the right tradeoff.

Most users don’t want to configure sample rate, channels, codec profiles, and command-line flags.

They just want the audio.

🔒 Why I Like Browser-Side Processing

One of the most interesting parts of building Vidoro has been deciding which jobs belong in the browser and which belong on the server.

For tasks like:

MOV → MP3
normal video compression
simple format conversion

browser-side FFmpeg can work surprisingly well.

There are several benefits.

No upload time

If someone has a 300 MB video, a server-based tool may require the entire 300 MB upload before processing even begins.

With browser processing, work can start locally.

Better privacy

The media file can remain on the user’s machine.

For private recordings, internal work videos, family videos, interviews, or other sensitive material, that is useful.

Lower backend infrastructure requirements

Simple media jobs don’t necessarily need to consume server CPU, storage, queues, and bandwidth.

But there are tradeoffs

WebAssembly processing is not magically faster than native FFmpeg.

Large files can consume a lot of browser memory, and mobile devices can struggle with demanding workloads.

That is why Vidoro also has a server-side architecture for jobs where browser processing is not the right choice.

🧱 The Tech Stack

Vidoro currently uses:

Frontend

Next.js 16
React 19
TypeScript
Tailwind CSS
App Router

Browser Media Processing

FFmpeg
ffmpeg.wasm
WebAssembly

Backend

FastAPI
Celery
Redis
PostgreSQL

Server Media Processing

FFmpeg
ffprobe

Deployment

The frontend is designed to run independently from the backend.

Browser-local tools can work without sending media to the backend at all, while server-assisted features use the FastAPI/Celery pipeline.

⚙️ How the Server Compression Pipeline Works

For server-assisted compression, the architecture is roughly:

Video upload
→ FastAPI
→ storage
→ Celery task
→ FFmpeg
→ compressed result
→ download

Redis handles the task queue, while the backend and Celery worker share the same storage volume.

That last part sounds obvious, but it caused one of the bugs I ran into.

The backend successfully saved a file to:

/app/storage/uploads/...

but the worker had a different container filesystem and saw an empty directory.

The API worked.

The upload worked.

The Celery task started.

Then the worker reported:

Input file missing

The fix was to use a shared Docker volume between the backend and worker.

That was one of those bugs where every individual component looked healthy, but the full workflow still failed.

🧪 Things I Learned

A few lessons from building the project so far:

Browser FFmpeg is useful, but it has limits

For many everyday jobs, ffmpeg.wasm is genuinely useful.

For very large 4K videos or CPU-heavy transformations, native server-side FFmpeg is still much more capable.

“AI” works better when it solves a specific problem

I don’t want Vidoro to add a chatbot just because AI is popular.

The useful application here is helping users answer questions like:

What settings should I use?

or:

How do I make this small enough for email?

That is much more practical than adding a generic chat panel.

Output-size prediction is harder than it looks

You can’t simply say:

output = original × 0.2

Video content, existing bitrate, motion, codec, resolution, and CRF all matter.

A prediction that looks impressive but is consistently wrong is worse than a conservative estimate.

Privacy can be a product feature

Moving media processing into the browser is not only an implementation detail.

It changes the user experience.

“No upload required” is something users can actually understand.

Keep the interface simpler than FFmpeg

FFmpeg exposes hundreds of options.

That doesn’t mean an online tool should.

The job of the product is often to hide complexity rather than reproduce a command-line interface in a browser.

🚧 What I’m Working on Next

I’m continuing to expand Vidoro with more focused media tools.

I’m also experimenting with a more intelligent workflow where users can describe what they want instead of choosing technical parameters.

For example:

“Make this video small enough to email.”

or:

“Extract the audio from this MOV.”

or:

“Make this smaller but keep the text readable.”

The long-term idea is that Vidoro can understand the task, choose the appropriate tool, and configure it automatically.

Underneath, the actual media processing can still be handled by deterministic tools like FFmpeg.

The AI layer would help with intent and parameter selection rather than replace the media-processing engine.

🌍 Try Vidoro

Homepage:

👉 https://vidoro.io/

English Video Compressor:

👉 https://vidoro.io/compress-video-online/

Portuguese Video Compressor:

👉 https://vidoro.io/pt/comprimir-video-online/

MOV to MP3 Converter:

👉 https://vidoro.io/mov-to-mp3-converter/

I’m still actively improving the project, especially browser performance, compression quality, UX, and the balance between local and server-side processing.

I’d love feedback on:

the browser-first approach
ffmpeg.wasm performance
the compression workflow
privacy positioning
the smart compression idea
mobile usability
which media tool would be useful to build next

I Built a Portuguese Video Compressor for Brazil Users

高赫阳 — Fri, 07 Aug 2026 06:40:06 +0000

When I was building a video compression tool, I noticed something interesting.

Many online tools are created mainly for English-speaking users. They work worldwide, but users from other languages often don't get a localized experience.

Brazil is a good example.

Video sharing is very common in Brazil, especially through WhatsApp and social media. Many users need to reduce video size before sharing, but there are not many simple tools designed for Portuguese speakers.

So I created a Portuguese version of my video compressor:

https://vidoro.io/pt/compactar-video

The tool works directly in the browser, allowing users to compress videos without installing additional software.

🇧🇷 Versão em português

Enquanto desenvolvia uma ferramenta de compactação de vídeos, percebi uma oportunidade interessante.

Muitas ferramentas online são criadas principalmente para usuários de inglês. Elas funcionam globalmente, mas nem sempre oferecem uma boa experiência para pessoas que falam outros idiomas.

No Brasil, muitas pessoas compartilham vídeos pelo WhatsApp, redes sociais e outras plataformas. Porém, encontrar uma ferramenta simples de compactação de vídeo em português nem sempre é fácil.

Por isso, criei uma versão em português:

https://vidoro.io/pt/compactar-video

A ferramenta funciona diretamente no navegador e permite reduzir o tamanho dos vídeos sem precisar instalar programas.

No futuro, também pretendo lançar uma versão em espanhol, pois existe uma grande demanda de usuários que falam espanhol na América Latina e em outras regiões.