// Tableau — calculated fields
// Tableau is drag-and-drop, but calculated fields
// are what separate a basic dashboard from a useful one.

Revenue
-------
[Qty] * [Unit Price]

Order Size
----------
IF [Revenue] >= 10000 THEN "Large"
ELSEIF [Revenue] >= 3000 THEN "Medium"
ELSE "Small"
END

Profit Margin
-------------
IF [Revenue] = 0 THEN NULL
ELSE [Profit] / [Revenue]
END

// Interviewers rarely ask you to recite functions —
// they ask you to explain WHY a calculation belongs
// in the view vs in the data source.

// Tableau — Level of Detail (LOD) expressions
// The Tableau skill interviewers test most,
// because it answers "per category" questions
// that simple aggregations cannot.

// First order date per customer
First Order Date
----------------
{ FIXED [Customer ID] : MIN([Order Date]) }

// New vs returning customers
Customer Type
-------------
IF [Order Date] = [First Order Date]
THEN "New"
ELSE "Returning"
END

// Total revenue per customer, on every row
Customer Revenue
----------------
{ FIXED [Customer ID] : SUM([Revenue]) }

// Rule of thumb:
// FIXED   -> ignore the view's filters/grouping
// INCLUDE -> add extra dimension to the view
// EXCLUDE -> remove a dimension from the view

// Tableau — table calculations
// These run on the RESULT set, not the raw rows.
// That single fact explains most "why is my number
// different?" questions in interviews.

Running Revenue
---------------
RUNNING_SUM(SUM([Revenue]))

% of Total Revenue
-----------------
SUM([Revenue]) / TOTAL(SUM([Revenue]))

Month-over-Month Growth
-----------------------
(SUM([Revenue]) - LOOKUP(SUM([Revenue]), -1))
/ ABS(LOOKUP(SUM([Revenue]), -1))

// Remember to set "Compute Using" to Month.
// Table calcs are correct only when the addressing
// direction matches what the business question means.

# Django — a first model
# File: courses/models.py

from django.db import models

class Course(models.Model):
    title       = models.CharField(max_length=200)
    description = models.TextField(blank=True)
    price       = models.DecimalField(max_digits=8, decimal_places=2)
    is_active   = models.BooleanField(default=True)
    created_at  = models.DateTimeField(auto_now_add=True)

    class Meta:
        ordering = ["-created_at"]

    def __str__(self):
        return self.title

# Then run:
#   python manage.py makemigrations
#   python manage.py migrate
#
# Django's ORM handles tables, indexes, and schema
# changes for you — no raw SQL needed to start.

# Django — a view and a URL
# File: courses/views.py

from django.shortcuts import render, get_object_or_404
from .models import Course

def course_list(request):
    courses = Course.objects.filter(is_active=True)
    return render(request, "courses/list.html", {"courses": courses})

def course_detail(request, pk):
    course = get_object_or_404(Course, pk=pk)
    return render(request, "courses/detail.html", {"course": course})

# File: courses/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path("", views.course_list, name="course_list"),
    path("/", views.course_detail, name="course_detail"),
]

# File: config/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path("admin/", admin.site.urls),
    path("courses/", include("courses.urls")),
]

<!-- Django template — course list -->
<!-- File: courses/templates/courses/list.html -->

<h1>Courses</h1>

<ul>
  {% for course in courses %}
    <li>
      <a href="{% url 'course_detail' course.pk %}">
        {{ course.title }}
      </a>
      <span>₹{{ course.price }}</span>
    </li>
  {% empty %}
    <li>No courses yet.</li>
  {% endfor %}
</ul>

<!-- Django templates use {% %} for tags,
     {{ }} for variables, and are safe by default
     against XSS. They also support inheritance
     via {% extends %}, which keeps layouts DRY. -->

Tableau — 30-day beginner plan:
Week 1: Connect data, core chart types, formatting
Week 2: Filters, calculated fields, parameters
Week 3: Dashboards, actions, LOD expressions
Week 4: One polished dashboard on a public dataset
        + publish to Tableau Public

Result: A shareable portfolio link.
        Interview-ready for junior analyst roles.

Total effort: ~30 hours. No coding prerequisites.

Django — 30-day plan:
(assumes Python + HTML + SQL basics)

Week 1: Install, project layout, "Hello, Django"
Week 2: Models, migrations, admin
Week 3: Views, templates, URLs, forms
Week 4: A small CRUD app deployed to Render or Railway

Result: A live app you can share.
        Ready for junior backend / full-stack interviews.

Not recommended without:
- Python fundamentals (functions, classes, modules)
- Basic HTML and CSS
- Basic SQL (SELECT, JOIN)
- Git comfort

If Python isn't yet solid, spend 6–8 weeks
on Python first — Django will then make sense.

Data / BI path (recommended order):
1. Excel                    (2-3 weeks)
2. SQL                      (4-6 weeks)
3. Tableau or Power BI      (4 weeks)
4. Python + Pandas          (4-8 weeks)
5. Statistics basics        (4 weeks)

Roles: Data Analyst, BI Developer, MIS Analyst,
       Reporting Analyst, Product Analyst

Django is not required on this path —
though analysts sometimes use Flask or Django
to build quick internal dashboards if Tableau
is not available.

Web / backend path (recommended order):
1. Python fundamentals      (6-8 weeks)
2. HTML + CSS basics        (2-3 weeks)
3. SQL basics               (2-3 weeks)
4. Django                   (4-6 weeks)
5. Git + deployment         (2 weeks)
6. (Optional) DRF + frontend(4-6 weeks)

Roles: Backend Developer, Python Developer,
       Full-Stack Developer, Data Engineer (tooling)

Tableau is not usually part of this path —
but some Python devs use it for internal
analytics dashboards to avoid building BI
from scratch.