DEV Community: Daniel Yang

How I Built a Minimalist Bilingual Etymology PWA for Mindful Coding & Study published: true tags: javascript, webdev, opensource, productivity

Daniel Yang — Tue, 20 Oct 2026 09:33:54 +0000

Hey everyone! 👋

As an independent creator and developer, I’ve been working on a project that bridges two seemingly different worlds: software development and ancient classical text etymology (Greek & Hebrew), combined with the concept of personal boundaries and mindful grounding.

Today, I’m excited to share how I built and deployed a lightweight, distraction-free Progressive Web App (PWA) called Turtle English entirely for free using GitHub Pages, Vue 3, and Tailwind CSS.

💡 The Motivation: Why Build This?
Most language or scripture study tools are cluttered with ads, overly complex interfaces, or heavy corporate frameworks. I wanted something completely different:

Zero friction: Open instantly on any device, no app store downloads required.

Deep deconstruction: Instead of blind translation, look at the root morphemes (e.g., discovering that Hupotasso isn't about blind submission, but about "arranging oneself into proper order/boundaries").

Mindful focus: A clean, dark-mode interface designed to bring peace and structural clarity during quiet work or study sessions.

🛠️ The Tech Stack & Architecture
To keep it lightning-fast and entirely serverless, I chose:

HTML5 + Vue 3 (Global Build via CDN): No heavy Node.js build steps needed for the frontend prototype, making it super easy to maintain and deploy.

Tailwind CSS: For a sleek, modern, distraction-free dark UI.

TypeScript-ready Core Logic: Structured data models for words, transliterations, root morphemes, and mindset cards.

GitHub Pages: For 100% free, reliable, and instant static hosting.

Here is a snippet of how the etymology search and keyword filtering service is structured:

JavaScript
// Core search and filtering logic using Vue 3 computed properties
const filteredResults = computed(() => {
const q = query.value.trim().toLowerCase();
if (!q) return DATABASE;
return DATABASE.filter(item => {
return item.transliteration.toLowerCase().includes(q) ||
item.lemma.includes(q) ||
item.id.toLowerCase().includes(q) ||
item.keywords.some(k => k.toLowerCase().includes(q)) ||
item.mindsetCard.exposition.toLowerCase().includes(q);
});
});
🚀 How It Looks & Works
Users can type any keyword (like Hupotasso, Shalom, or psychological boundary concepts) and instantly retrieve structured breakdown cards:

Original Lemma & Transliteration (e.g., ὑποτάσσω / Hupotasso)

Literal Etymology Morphemes (Breaking down hupo + tasso)

Mindset & Boundary Application (Bridging ancient text with modern emotional/mental grounding)

Because it's a PWA, users on mobile devices (iOS/Android) can simply tap "Add to Home Screen" and use it completely offline like a native app.

🌐 Try It Out & Open Source
If you are curious about language tools, minimal PWA development, or just want to see how it works, you can check it out here:

Live PWA App: https://danielenglish19960118.github.io/turtle-app/

GitHub Repository: https://github.com/danielenglish19960118/turtle-app

I’d love to hear your thoughts, feedback, or any ideas on how to improve lightweight PWA architectures. Have you ever built a micro-tool to solve a personal workflow or study problem? Let’s chat in the comments! 👇

Why I ditched complex tech stacks and built a zero-overhead Micro-SaaS in a single HTML file

Daniel Yang — Fri, 02 Oct 2026 06:49:59 +0000

As developers, we love building complex architectures. We reach for React, TypeScript, complex state managers, Docker containers, and robust PostgreSQL databases even for the smallest side projects.

Recently, I caught myself falling into that exact trap. I wanted to build a simple utility tool—MNC Review Copilot—to solve a deeply personal pain point: turning messy, chaotic management notes into polished, professional, STAR-compliant English performance reviews for multinational corporations.

Instead of spending weeks setting up a heavy full-stack boilerplate, I decided to run an experiment: How far can I get with a radical "zero-overhead" architecture?

Here is why I went back to basics, how I built it, and what I learned along the way.

The Single-File Philosophy As a solo creator, every minute spent wrestling with a build pipeline, database migration, or server configuration is a minute stolen from shipping value to users.

To eliminate maintenance overhead entirely, I designed the entire app around a single-file philosophy:

No Build Step: The core logic lives in a clean, maintainable structure using vanilla JavaScript and Tailwind CSS injected via CDN.

Instant Deployment: Shipped directly to Vercel as a static app.

Zero Infrastructure Cost: No heavy backend, no database queries to optimize, and near-zero server maintenance. The profit margins on every subscription sit comfortably at 95%+.

Here is a glimpse of how lightweight the foundation is:

HTML
<!DOCTYPE html>

MNC Review Copilot

The Realities of Bootstrapping & SEO Building the app was the fun part. Putting it in front of people? That’s where reality hits.

The Algorithm Wall: If you've tried launching on major tech platforms or social aggregators as a new indie hacker, you already know how aggressive automated filters and shadowbans can be.

The Pivot to Owned Assets: Instead of fighting black-box algorithms or paying for traffic, I shifted my focus to search-intent optimization (SEO) and technical storytelling. When time-poor managers are up late searching for terms like STAR method performance review templates or AI tools for corporate writing, they don't care if your app uses a complex microservices architecture—they care that it solves their problem instantly. By writing transparent development logs and technical breakdown posts, the content itself acts as an evergreen acquisition channel.

Key Takeaways for Indie Hackers Solve your own friction first: If you feel an intense, recurring pain in your professional or daily life, chances are thousands of others share it.

Small is sustainable: You don't need venture-backed infrastructure to launch a useful tool. A sharp pain point, a clean interface, and a fast deployment loop are often all it takes.

Keep your stack boring: Save your creative energy for solving user problems, not debugging framework updates.

Wrap Up
If you are a developer looking to ship a micro-SaaS without burning out on server maintenance, or a manager trying to survive review season, you can check out the live app via the link in my profile bio.

What is the most annoying, repetitive task in your workflow that you've automated away? Let's chat in the comments!