DEV Community: manjushaps

Generate Student Reports in Rust with HTML Templates and PDF Export

manjushaps — Fri, 10 Jul 2026 05:06:14 +0000

What if student reports were generated like web pages first, and only then exported as PDFs?

The latest post on Techn0tz explores that workflow in the Teacher Assistant App using Rust, egui, and PostgreSQL. Instead of generating PDFs directly, the report pipeline starts with reusable HTML templates. Student-specific values are inserted through placeholder replacement, the generated reports are organized into class-and-exam folders, and the final HTML output is rendered into PDF.

The post covers:

building a reusable HTML report template
generating one report per student from the selected class
replacing placeholders with student details, totals, and percentages
sanitizing file names for safe report export on Windows
organizing reports into class-and-exam specific folders
converting generated HTML reports into PDFs
opening the exported reports folder directly from the app

👇Read the full workflow here:
🔗Html to Pdf export workflow

If you read it, I’d love to know what part of the workflow feels most useful — the template design, the HTML-to-PDF export flow, or the report organization side.

- Manjusha (Techn0tz)

Building a Dynamic Grades and Report Generation System in Rust

manjushaps — Wed, 27 May 2026 14:12:48 +0000

What happens when a marks entry interface stops being fixed and becomes entirely data-driven?

The latest phase of the Teacher Assistant application explores building a scalable grades and report generation system using Rust, egui, and PostgreSQL.

Instead of treating marks entry as another CRUD screen, the implementation evolved into a fully data-driven interface capable of adapting dynamically based on the selected exam and subject configuration.

Key parts of the system include:

Dynamic exam and subject management
Runtime-generated marks grids
Real-time total and percentage calculation
State-driven UI synchronization
Adaptive layouts for varying subject counts
Bulk marks persistence using UPSERT-style workflows

One of the key implementation challenges was designing a marks interface capable of handling completely different subject structures without modifying the underlying UI layout.

The UI was no longer fixed — selecting a different exam could regenerate the entire marks grid at runtime.

The article explores:

Relational database design for exams, subjects, and grades
Trigger-based state synchronization inside egui
Dynamic subject loading
Scrollable adaptive marks grids
Runtime-generated calculations and validations
Preparing the foundation for future HTML/PDF report generation

The post also includes screenshots and a visual walkthrough of the adaptive marks interface.

👇Read the full implementation breakdown:
Designing Grades Panel

Feedback and suggestions are always welcome.🙂

— Manjusha (Techn0tz)

Techn0tz Turns 1 — Help Shape What’s Next

manjushaps — Sat, 18 Apr 2026 05:07:16 +0000

Techn0tz turns 1 🎉

It started as a simple space to document learning.

Over time, it evolved into building real applications in Rust — focusing on how things work, not just how to write them.

The next phase moves toward deeper features and more structured learning.

To make this more useful, a quick survey has been added:

👉 Takes less than 1 minute ⏱️
🔗 Open 1-Minute Survey

Your input will directly influence what comes next.

💬 Feedback is welcome.

Stop Checking if Records Exist: Using UPSERT in Rust to Prevent Duplicate Data

manjushaps — Thu, 16 Apr 2026 14:18:12 +0000

Re-running an import shouldn’t change your data. But does it?

Handling repeated operations is a common problem in applications that deal with imports, sync logic, or user-triggered actions.

A simple “insert” works the first time — but running the same operation again can lead to duplicate records, failed inserts, or complex conditional logic in the application layer.

This post explores a cleaner approach:

👉 Using UPSERT to let the database handle conflicts instead of relying on “check-then-insert” patterns.

It covers:

Why traditional insert/update logic becomes difficult to maintain
How UPSERT works in SQLite
A simple Rust + SQLx demo
Clear before vs after behavior
Common mistakes to avoid

👇 Read the full post:
UPSERT in Rust

Feedback and suggestions are always welcome.🙂

Thanks for reading🌱
— Manjusha (Techn0tz)

SQLite and PostgreSQL — Both in One Rust Application

manjushaps — Wed, 01 Apr 2026 14:42:53 +0000

Most applications force you to choose: SQLite or PostgreSQL.

This one doesn’t.

One Rust application, two databases, same core logic.

This post explores how a single codebase can switch between SQLite (zero setup) and PostgreSQL (scalable) — without duplication or branching.

unified connection layer (sqlx::AnyPool)
runtime database selection
schema differences
real-world challenges

No theory-heavy explanations. Just how it actually works.

👇 Read the full post
Rust with SQLite and Postgres

Curious to hear your thoughts 🙂

Thanks for reading🌱
— Manjusha (Techn0tz)

Rust Data Structures Quiz: 15 Short Snippets That Test How You Think

manjushaps — Wed, 18 Mar 2026 14:13:40 +0000

Some Rust code looks simple.

Until you try to predict what it actually does.

This is a thinking-based Rust quiz built around data structures — where each question is a short code snippet designed to make you pause and think before answering.

15 questions. ~5 minutes. No long explanations. No theoretical questions.

Just:

Vec behavior
HashMap and ordering
Binary search edge cases
Sorting and complexity
Subtle data structure behavior

👇Try it before reading the answers
Rust Data Structures Quiz

How many did you get right? Share in the comments 🙂

Thanks for reading 🌱
— Manjusha (Techn0tz)

From Excel to Smart Sync: Designing a Safe Student Data Import System in Rust (SQLite + PostgreSQL)

manjushaps — Wed, 11 Mar 2026 14:37:43 +0000

Most classroom data starts in Excel.

Names, roll numbers, sections, parent contacts — all stored in a sheet that slowly begins behaving like a system.

But importing spreadsheets into a database introduces a different challenge:
how do updates, duplicates, and missing records stay consistent over time?

A new Techn0tz article walks through a Smart Sync workflow in Rust that connects Excel with a structured database while keeping data safe.

The workflow includes:

• Exporting class data to Excel
• Controlled insert and update logic
• Optional synchronization for removing outdated records
• Confirmation safeguards before deletion
• Support for both SQLite (teacher mode) and PostgreSQL (organization mode)

A short demo shows the entire process — from automatic database creation to Excel synchronization.

👇Read the full post + demo here
Excel to Smart Sync

Feedbacks and suggestions are always welcome!😊

Thanks for reading🌱
—Manjusha (Techn0tz)

Building a Role-Based Student Management System in Rust (egui + PostgreSQL)

manjushaps — Thu, 19 Feb 2026 13:30:29 +0000

Authentication answers one question: Who are you?

Authorization answers the next: What are you allowed to do?

After connecting the login system to PostgreSQL, the Teacher Assistant application moved beyond authentication into a role-aware system.

The dashboard, navigation, and student records now adapt dynamically based on the authenticated user's role.

This stage introduces:

Role-based dashboards with controlled navigation
PostgreSQL-backed student CRUD operations
Class-based filtering tied to teacher assignments
Permission-controlled editing and deletion
State-driven UI using Rust and egui

The interface now reflects identity, role, and database state—rather than static UI logic.

👉 Read the full post here: Dashboard and Student CRUD

Feedback and suggestions are welcome.

Thanks for reading
— Manjusha (Techn0tz)

Rust Data Structures You’ll Actually Use (With Runnable Code)

manjushaps — Mon, 09 Feb 2026 14:39:27 +0000

A practical guide to the collections that power real Rust apps.

Every example runs with cargo run.

No theory dumping — just:

• practical examples
• real use cases
• working code

Covers Vec, HashMap, VecDeque, BTreeMap, searching, sorting, and Big-O.

Clean. Simple. Straight to the point.

👇Read here:
Rust Data Structures

Feedback and suggestions welcome.

Thanks for reading🌱
— Manjusha(Techn0tz)

Rust Quiz 3 & 4 – Mini Challenges, Ownership, and Real-World Rust

manjushaps — Thu, 29 Jan 2026 13:42:32 +0000

Can you predict what Rust code prints… without running it? 🤔

I added two short interactive Rust quizzes for quick practice.

Topics include:

mini coding challenges
ownership, borrowing, lifetimes
Rust in real-world systems and tools

Each quiz has:

10–15 MCQs
5-minute timer
instant scoring
answers + explanations

👇Try them here:
Quiz 3 → Ownership, Borrowing & Lifetimes

Quiz 4 → Mini Challenges & Future Tech

Feedback or suggestions are always welcome 🙂

Thanks for reading🌱
— Manjusha(Techn0tz)

Building a Login Panel with PostgreSQL Authentication in Rust (egui + sqlx)

manjushaps — Thu, 22 Jan 2026 13:32:41 +0000

Login + database auth sounds simple… until you build it.

Just finished integrating authentication into Level 3 of my Teacher Assistant desktop app.

Instead of a tutorial-style guide, I documented the real engineering process:

connecting egui → PostgreSQL using sqlx
structuring login state inside update()
password hashing with Argon2
common errors (TRUNCATE notice, DB auth failure, trait issues, query mismatches)
and the final working login → dashboard flow

Sharing the real dev journey, not just the happy path.

👉 Full write-up: Login with PostgreSQL Authentication

Feedback and suggestions are welcome!

Thanks for reading🌱
— Manjusha (Techn0tz)

How 4 Japanese Concepts Help Me Build Techn0tz Consistently

manjushaps — Mon, 05 Jan 2026 13:45:56 +0000

To begin 2026, I wrote a reflective piece on my blog, Techn0tz.

It’s about four Japanese concepts — Kaizen, Shinrin-yoku, Wabi-sabi, and Kintsugi — and how they’ve influenced the way I approach long-term projects during slower or quieter phases.

This isn’t a self-improvement post or a productivity guide. It’s simply a reflection on sustaining creative and technical work over time.

👉 How 4 Japanese Concepts Help Me Build Techn0tz Consistently

Wishing everyone a thoughtful start to the year 🎊

Thanks for reading 🌱
— Manjusha (Techn0tz)