1:1 Mentorship · RTL & SoC Engineering

Most engineers write RTL.
Few understand why it breaks.

This is not a course. This is a working session — focused on how you think through design decisions, integration challenges, and real-world constraints. If you want to move beyond execution and start reasoning like a system-level engineer, this is where to start.

Book a 1:1 Session

The Session

What happens in a 1:1

Each session is built around your specific problem — not a fixed curriculum. You bring the context. We work through it together.

Break down where your thinking is getting stuck — in a project, an interview, or a concept
Identify the gap between what you know and how you're applying it
Build a method you can reuse, not a one-time answer
Work through real-world scenarios: timing trade-offs, debug strategies, design decisions under constraints

Focus Areas

What I help with

RTL Design

Writing RTL that holds up beyond simulation
Understanding timing, area, and power trade-offs in context
Common RTL decisions that create downstream problems
Designing for integration, not just for functionality

Debugging

Approaching multi-variable failures systematically
Isolation strategies when the bug isn't obvious
Reducing dependency on others to resolve issues
Reading simulation and synthesis results critically

System & SoC Thinking

How your block fits into a larger system
Integration challenges and ownership boundaries
Cross-team constraints and how to navigate them
STA, CDC, and real-world silicon considerations

Career & Interviews

How senior and staff roles are actually evaluated
Answering design questions with depth, not recall
Positioning your experience to match what matters
Identifying and fixing gaps before the interview

Philosophy

How I see design

Design is not coding.

Coding is the final step — used to express a solution that has already been thought through. The real work happens before that: understanding the problem, defining the architecture, evaluating trade-offs, deciding what matters and what doesn't.

In real product environments, most of the effort goes into making these decisions. The actual implementation often happens toward the end, once the direction is clear.

May not be the right fit if you want to

Improve coding syntax
Practice RTL like a programming exercise
Build a coding-focused career

What this mentorship focuses on

How to approach a design problem from first principles
How to think in terms of architecture, not just modules
How to make trade-offs between performance, power, and area
How to arrive at solutions that work at system level — not just in isolation

Developers focus on writing code.
Designers focus on defining what should be built — and why.

This mentorship is built around the second approach.

Fit

Who this is for

Engineers with 1 to 10 years of experience in RTL, ASIC, or FPGA roles
People who can write code but struggle to explain or defend design decisions
Those targeting Senior or Staff-level roles and unclear on what the gap is
Anyone preparing for ASIC or VLSI interviews who wants structured thinking, not memorized answers
Engineers feeling stuck at the execution level who want to operate more independently

Background

About me

I work on product-level RTL and SoC integration — not academic projects. My work has involved real constraints: synthesis timelines, silicon behavior, cross-team integration, and debugging issues that show up only in the full system context.

My focus has been understanding how designs behave under real conditions, not just in simulation. That means thinking in terms of timing budgets, clock domains, power intent, and integration boundaries — before writing a single line of code.

I do not teach through spoon-feeding or memorization. Sessions are interactive and problem-driven. The goal is to change how you think, not add to what you've memorized.

I work at the intersection of design and integration — where the real problems live.

Purpose

Why this exists

The gap between academic learning and real engineering is wider than most people realize. Courses teach syntax. Colleges teach theory. Neither teaches you how to think under constraints, debug in ambiguity, or make decisions that hold at scale.

This mentorship is an attempt to close that gap — one session at a time. No generic advice. No recycled frameworks. Just direct engagement with your actual problem.

Tranquil Light Foundation

A part of this work feeds into TLF — an initiative focused on helping students and early professionals gain clarity on direction. The goal is straightforward: reduce the time people spend lost in transition between learning and working.

Process

How sessions work

You book a slot and come with a specific problem, topic, or question. No prep needed beyond knowing what you want to work on.

We work through it together — live, interactive, no fixed script. The session follows the problem, not a template.

You leave with a clearer approach, not just an answer. The method should work on the next problem too.

Most engineers write RTL.Few understand why it breaks.