DEV Community: Max/Wang

Browser-based DOCX to PDF converter using Pandoc and Typst (WASM)

Max/Wang — Thu, 12 Feb 2026 16:02:26 +0000

Hi Fr,

I built a Word-to-PDF converter that runs 100% in your browser. No files ever touch a server.

The Stack

The challenge was handling the complex layout of .docx files without a heavy backend. I settled on a "double-engine" approach using WebAssembly:

Pandoc (WASM): Used to parse the DOCX structure and convert it into Typst code. I’m utilizing a WASI shim to run Pandoc's Haskell-compiled WASM in the browser.
Typst (WASM): Instead of using a heavy TeX engine, I used Typst's modern rendering engine to turn the intermediate code into a polished PDF.

Technical Highlights

Media Extraction: The tool extracts images from the DOCX file via Pandoc’s --extract-media, maps them into a virtual file system (WASI), and then passes them to Typst for final rendering.
Custom Fonts: To support multi-language characters (especially CJK), I’m side-loading custom fonts (GenYoGothic) into the Typst compiler within the worker.
Svelte 5: The UI is built with Svelte 5, leveraging its new runes ($state, $derived) for a very snappy, reactive file queue management.
Web Workers: All the heavy lifting (WASM instantiation and conversion) happens in a dedicated worker to keep the UI at a buttery 60fps.

Why Pandoc + Typst?

Pandoc is the swiss army knife of document conversion, but its direct PDF output usually requires a LaTeX distribution. By routing it through Typst, I can get high-quality PDF output with a much smaller WASM footprint and faster rendering times.

I’d love to hear your thoughts on the performance or any edge cases you find with complex DOCX layouts!

I Spent 3 Years in the App Store. Now I'm Building My First SaaS in Public.

Max/Wang — Mon, 06 Oct 2025 14:55:53 +0000

Hey devs!

For the last three years, my world has been Xcode, Swift, and the App Store's monetization maze. It's been an incredible learning experience, but I've always been curious about the web and the SaaS world—a completely different beast with its own rules.

Today, I'm finally diving in and sharing the start of a new public experiment: mktgrowkit.com.

So, What Did I Build?
At its core, https://mktgrowkit.com is a simple, free suite of marketing calculators (ROAS, CPM, etc.). I built it to scratch my own itch: I needed quick, no-fluff tools to make data-driven decisions for my apps without hitting a paywall or signing up for a complex platform.

The Tech Stack
As a mobile dev, jumping into the modern web ecosystem was fun. Here’s the stack I chose for the MVP:

Framework: Nuxt.js. I chose this specifically for the out-of-the-box Server-Side Rendering (SSR), which is crucial for my SEO-centric strategy.

Styling: Tailwind CSS. It allowed me to build the UI incredibly fast without writing a lot of custom CSS.

Deployment: Vercel. The seamless Git integration and global CDN made launching and iterating a breeze.

Backend: Currently static, but I'm using Supabase for some server-side logic and plan to integrate it more for future features.

The Real Challenge: From ASO to SEO
Building the tool was familiar territory. The real experiment is the challenge I've set for myself: Can I grow this from zero purely through Search Engine Optimization?

No paid ads, no big launch campaign. Just the long, slow grind of content creation, technical SEO (sitemaps, canonicals, Core Web Vitals), and authority building. It's a whole new world compared to the ASO (App Store Optimization) I'm used to. It feels daunting, but as an engineer, I'm excited by the technical challenge of it.

Why Build in Public?
I'm a huge believer in learning from others, so I'm committing to tracking this entire journey in public—the good, the bad, and the ugly. I'll be sharing traffic stats, keyword rankings, technical hurdles, and any lessons learned along the way.

I'd love to hear from other devs who have made a similar jump from mobile to web.

What was your biggest "aha!" moment or surprise?

Any advice on surviving the SEO grind?

If you want to follow the data and see how this experiment plays out, I'm posting all my updates on X (Twitter). I've created this pinned tweet to track the journey: [Link đến Pinned Tweet của bạn]

Thanks for reading!

I just launched TL;Dev, a curated collection of notes for developers and indie builders.

Max/Wang — Wed, 27 Aug 2025 14:38:14 +0000

Hey everyone,

Like many of you, I spend a lot of time on Reddit, X, and YouTube looking for interesting case studies and strategies. The problem is, there's too much content and not enough time. I'd save dozens of links intending to read them later, but that "later" never came.

So, I built a solution for myself called TL;Dev.

It's a simple, no-BS website where I personally curate and summarize the most valuable content into short, easy-to-read notes. The goal is to help developers and indie builders grasp the core ideas in minutes, not hours.

My site is covering everything from successful launches to costly failures.

It's 100% free, no paywall, no annoying pop-ups. Just content.

For those interested, it’s built with Astro and deployed on Cloudflare. It's ridiculously fast.

I'm posting here because I think it could be genuinely useful for this community, and I'd love to get your feedback on the site, the content, or any ideas you might have.

You can check it out here: https://tldev.co

Thanks for reading!!

How to Find Profitable App Ideas (Even If You Think Everything Already Exists)

Max/Wang — Fri, 28 Feb 2025 08:29:31 +0000

Finding a great app idea can feel impossible—especially when it seems like every idea has already been done. But the truth is, you don’t need a 100% original idea to succeed. You just need to build something that solves a real problem in a better way.

Why You Don’t Need a Completely Original App Idea

Many aspiring indie developers believe that success comes from launching a completely new, never-before-seen product. But in reality, most successful apps weren’t the first of their kind—they were just better, simpler, or more focused than existing solutions.

Think about physical products: there are dozens of energy drink brands, water bottles, and vanilla ice creams, yet all of them make millions. Apps work the same way.

How to Find a Profitable App Idea That Actually Works

Instead of chasing originality, focus on solving real problems for a well-defined audience. Here’s a proven framework to discover high-potential app ideas:

1. Start with a Niche You Understand Deeply

The best ideas come from inside knowledge of a specific market. If you personally experience a problem, chances are thousands of others do too.

What are the biggest challenges in industries you’re familiar with?
What daily annoyances do you or your colleagues face?
Have you ever said, “I wish there was an app for this”?

Start by identifying problems in an area where you already have expertise.

2. Study Communities to Discover Hidden Needs

Instead of forcing an idea, immerse yourself where your target audience hangs out:

Reddit, Discord, Slack, Twitter (X), and Facebook groups
Product review sites like G2, Capterra, and App Store reviews
Quora and niche forums where people ask for advice

Look for repeated frustrations or complaints about existing solutions. When you see the same pain point mentioned repeatedly, you’ve found a validated demand.

3. Improve on an Existing App Instead of Reinventing the Wheel

Rather than struggling to come up with a unique idea, find a popular app and make a better version:

Make it simpler, cheaper, or faster
Solve a missing pain point
Focus on a specific audience (e.g., a budgeting app tailored for freelancers)

Many successful startups started this way—Slack improved on workplace chat, Notion refined note-taking, and Duolingo made language learning more engaging.

4. Test Demand Before Writing a Single Line of Code

Before building, validate your idea:

✅ Post about it on social media and gauge interest
✅ Run a small paid ad campaign to see if people click
✅ Create a simple landing page and collect email signups
✅ Ask potential users directly in communities

If no one is excited, pivot or refine the idea before coding.

Four Must-Have Ingredients for a Successful App Idea

To maximize your chances of success, your app idea should check these boxes:

Easy to Build – Aim to launch an MVP within 30 days.
Solves a Clear Pain Point – The problem should be urgent and painful.
Has an Audience You Can Reach – If you don’t know where your users hang out, it’ll be hard to market.
Excites You Enough to Stay Committed – If you’re not passionate about it, you’ll quit too early.

The Proven Formula for Finding Profitable App Ideas

Identify a niche you know well
Find a real problem people complain about
Improve an existing solution or fill a gap
Test interest before coding
Launch, get feedback, and iterate

🚀 You don’t need the next "big idea"—just a product that solves a real problem for real users.

Ready to find your next app idea?

Start by diving into online communities and observing what people truly need!

Why Developers Struggle to Make Money with Apps (And How to Fix It)

Max/Wang — Thu, 27 Feb 2025 07:30:00 +0000

Developers love building things. We get excited about new ideas, start coding right away, and create something we think is amazing. But then… nothing happens.

📉 No downloads. No revenue. Just silence.

Why? Because we often forget to ask the most important question—Does anyone actually need this app?

Why Market Research Matters More Than Your Code

❌ Most developers build first and validate later. That’s a mistake.

Here’s how to avoid wasting months on an app no one wants:

✅ Analyze the market.

Look at similar apps. If an app in your niche is making money, that’s a strong sign of demand.
If there are zero competitors, be careful—maybe there’s no market.

✅ Read user reviews on the App Store.

1-2 star reviews = complaints & frustrations.
4-star reviews = users love the app but want improvements.
Find gaps and build a better alternative.

✅ Check ASO keywords.

Use Sensor Tower or AppTweak to see if people are searching for solutions like yours.
If search volume is low, validate on Reddit, Google Trends, or Facebook groups before building.

The Mistake I Made (And What I Learned)

I once spent a whole month building an app that I thought was genius.
Launched it… and nothing happened.

🚀 Not because the app was bad—but because nobody needed it.

💡 Don’t make the same mistake. Before writing a single line of code, validate your idea.

How I Built an iOS App That Made $1,400 in 90 Days (Lessons Learned)

Max/Wang — Wed, 26 Feb 2025 16:18:58 +0000

I started with zero downloads, no marketing, and no clue if my iOS app would make money.

📊 Fast forward 90 days:
💰 $1,400 revenue
📆 $347 in the last 30 days
📈 $2,850 total since launch

Not life-changing, but proof that even a small app can generate real income.

The process wasn’t smooth. I made mistakes, wasted time, and almost gave up. But after testing and refining, I found what actually works when it comes to making money with iOS apps.

🚀 6 Key Lessons I Learned
💡 1. Build What You Love, But Validate Demand
Most devs start with an idea they love, but that’s not enough. There has to be demand.
✅ Check Google Trends, Reddit, Twitter.
✅ Look at App Store reviews to see common complaints.
✅ If nobody is looking for it, don’t build it.

💡 2. Marketing is More Important Than Coding
Most devs think "build it and they will come." Nope. Without marketing, your app is invisible.
✅ ASO (App Store Optimization) matters.
✅ Running Apple Search Ads, even with a small budget, can make a huge difference.
✅ Leverage social media (Twitter, Reddit) to drive early traction.

💡 3. Monetization Matters From Day One
✅ Don’t just launch a free app and hope for ad revenue.
✅ Subscriptions are better for long-term revenue.
✅ In-App Purchases (IAPs) work well if you offer real value.

🎯 I go into full detail in this breakdown video:

💡 Thinking about launching an iOS app? Watch this before you start!

Unlocking the Power of App Intents: Prepare Your App for the AI Revolution

Max/Wang — Thu, 24 Oct 2024 08:53:17 +0000

The whispers in the tech world are getting louder: AI is poised to become a central player in the iOS ecosystem. As developers, we're always looking for ways to stay ahead of the curve, and App Intents might just be the key to unlocking the potential of this AI revolution. While often overlooked, App Intents offer a powerful way to expose our app's functionality to the broader operating system, including Siri, Spotlight, and Widgets.

Imagine a future where users can seamlessly interact with your app through natural language commands, effortlessly completing tasks without even opening the app. This is the promise of App Intents, and with the rise of AI, their importance is only set to grow.

Why App Intents Matter in an AI-Driven World

App Intents act as a bridge between your app and the system's intelligence, allowing Siri to understand and execute actions on behalf of the user. By defining clear intents and parameters, you empower Siri to perform tasks such as adding items to a shopping list, starting a workout, or sending a message, all through voice commands or automated shortcuts.

With Apple's increasing focus on AI, it's likely that Siri will become even more integrated into our daily lives. This means that apps that leverage App Intents will have a significant advantage, offering users a frictionless and intuitive experience.

A Practical Example: Building a Feature Wishlist with App Intents

Let's dive into a real-world example to see how App Intents work in practice. We'll create a simple app called "Features," which allows users to maintain a wishlist of features for Apple platforms. Using SwiftData and SwiftUI, we'll implement an App Intent that enables users to add new features to their wishlist using Siri.

Step 1: Defining the Data Models

First, we define our data models: Feature and Platform. A Feature has a title, description, and a corresponding Platform. The Platform is an enum representing various Apple platforms.

import SwiftUI
import SwiftData

// MARK: - Feature

@Model
class Feature {
    var id: UUID = UUID()
    var title: String = ""
    var featureDescription: String = ""
    var platform: Platform = .iphone

    init(
        title: String,
        featureDescription: String,
        platform: Platform
    ) {
        self.id = UUID()
        self.title = title
        self.featureDescription = featureDescription
        self.platform = platform
    }
}

To enable Siri to understand our Platform model, we make it conform to the AppEnum protocol. This involves providing display representations for both the type and its cases.

import SwiftUI
import AppIntents

// MARK: - Platform

enum Platform: String, CaseIterable, Identifiable, Codable, AppEnum {
    case allPlatforms = "All Platforms"
    case iphone = "iPhone"
    case ipad = "iPad"
    case applewatch = "Apple Watch"
    case visionPro = "Vision Pro"
    case mac = "Mac"
    case appletv = "Apple TV"

    var id: Self {
        return self
    }

    // ... (icon code omitted for brevity)

    static var typeDisplayRepresentation = TypeDisplayRepresentation(stringLiteral: "Platform")

    static var caseDisplayRepresentations: [Platform: DisplayRepresentation] = [
        .allPlatforms: "All Platforms",
        .iphone: "iPhone",
        .ipad: "iPad",
        .applewatch: "Apple Watch",
        .visionPro: "Vision Pro",
        .mac: "Mac",
        .appletv: "Apple TV"
    ]
}

Step 2: Managing Features with FeatureManager

Next, we create a FeatureManager class to handle the creation, retrieval, updating, and deletion of Feature objects.

import SwiftUI
import SwiftData

// MARK: - Feature Manager

class FeatureManager: ObservableObject {
    // ... (Properties and Init code omitted for brevity)

    func addFeature(title: String, description: String, platform: Platform) {
        withAnimation {
            let feature = Feature(
                title: title,
                featureDescription: description,
                platform: platform
            )
            modelContext?.insert(feature)
        }
    }

    // ... (deleteFeature code omitted for brevity)
}

Step 3: Creating the App Intent

Now, we define the CreateFeature App Intent, which allows users to add new features to their wishlist through Siri. We specify the intent's title, parameters, a summary of its action, and the code to perform when invoked.

import SwiftUI
import AppIntents

// MARK: - Create Feature App Intent

struct CreateFeature: AppIntent {
    // ... (Properties code omitted for brevity)

    @Parameter(title: "Platform", requestValueDialog: "Where would you like to see this feature?")
    var platform: Platform

    @Parameter(title: "Title", requestValueDialog: "What's the title of the feature?")
    var title: String

    @Parameter(title: "Description", requestValueDialog: "What's the description of the feature?")
    var description: String

    // ... (Summary code omitted for brevity)

    @MainActor
    func perform() async throws -> some IntentResult & ReturnsValue<String> {
        FeatureManager.shared.addFeature(
            title: title,
            description: description,
            platform: platform
        )
        return .result(value: "New Feature for \(platform.rawValue)\n\n\(title):\n\(description)")
    }
}

Step 4: Exposing the App Intent to Siri

Finally, we expose our CreateFeature App Intent to Siri through an AppShortcutsProvider. This involves defining an App Shortcut that links to our intent and providing phrases that users can say to trigger it.

import Foundation
import AppIntents

// MARK: - App Shortcuts

struct AppShortcuts: AppShortcutsProvider {
    @AppShortcutsBuilder
    static var appShortcuts: [AppShortcut] {
        AppShortcut(
            intent: CreateFeature(),
            phrases: ["Make a New \(.applicationName)"],
            shortTitle: LocalizedStringResource(stringLiteral: "New Feature"),
            systemImageName: "apple.logo"
        )
    }
}

Key Takeaways

App Intents are crucial for integrating your app with system functionalities like Siri, Spotlight, and Widgets.
As AI becomes more prevalent in iOS, App Intents will play an even greater role in enhancing user experience.
By defining clear intents and parameters, you enable Siri to understand and execute actions within your app.
Investing time in learning and implementing App Intents can significantly improve your app's discoverability and user engagement.