Learning path
Looker learning path: everything to study, topic by topic
Comprehensive Looker assessment covering LookML fundamentals (views, dimensions, measures, models, explores), data modeling with joins and refinements, derived tables and PDTs, dashboard design and embedding, administration and governance, and advanced LookML patterns including Liquid templating and the Looker API.
Short answer
To learn Looker, work through 6 modules and 26 topics in the order they build on each other. It starts with LookML Fundamentals, then moves on to Data Modeling and Derived Tables & PDTs. Use the map as a checklist, or measure your level and study only what is missing.
What you will study
Topics are grouped by module. Open one to see its objectives and key concepts.
1 · LookML Fundamentals5 topics
LookML Views
View files and their relationship to database tables, view parameters, sql_table_name, derived table references, field-level settings, and view organization best practices
Objectives
- Create LookML views that map to database tables
- Organize views with proper naming conventions and field grouping
Key concepts
- view file
- sql_table_name
- view parameters
- field organization
- view label
- view naming
Dimensions
Dimension types (string, number, date, yesno, tier), dimension groups for dates, sql parameter expressions, hidden dimensions, and primary keys
Objectives
- Define dimensions of various types with correct sql expressions
- Use dimension groups to create time-based analysis fields
Key concepts
- dimension types
- dimension groups
- sql parameter
- primary key
- hidden
- yesno
Measures
Measure types (count, sum, average, min, max, count_distinct, list), filtered measures, sql parameter for custom aggregations, and measure formatting
Objectives
- Create measures using standard and custom aggregation types
- Apply filters and formatting to measures for accurate business metrics
Key concepts
- measure types
- count_distinct
- filtered measures
- sql aggregation
- value_format
- drill_fields
LookML Models
Model files, connection declaration, include statements, explore definitions within models, datagroup triggers, access grants, and model-level settings
Objectives
- Configure LookML model files with proper connection and include settings
- Define datagroups for caching and PDT rebuild strategies
Key concepts
- model file
- connection
- include
- datagroup
- access_grant
- persist_with
Explores
Explore definitions, setting labels and descriptions, fields parameter for controlling field visibility, always_filter, conditionally_filter, and explore-level access control
Objectives
- Define explores with appropriate labels, filters, and field visibility
- Apply access filters and conditional filters for governance
Key concepts
- explore
- fields parameter
- always_filter
- conditionally_filter
- label
- access_filter
2 · Data Modeling5 topics
Joins in LookML
Join types (left_outer, inner, full_outer, cross), join relationships (many_to_one, one_to_many, many_to_many, one_to_one), sql_on clause, and fan-out/chasm trap prevention
Objectives
- Configure joins with correct types and relationship declarations
- Identify and prevent fan-out issues using symmetric aggregates
Key concepts
- join type
- relationship
- sql_on
- fan-out
- chasm trap
- symmetric aggregates
LookML Refinements
Refinement syntax with the plus (+) operator, refining views and explores without modifying original files, refinement use cases, ordering of refinements, and project organization
Objectives
- Use refinements to extend views and explores without editing original files
- Organize LookML projects with refinements for maintainability
Key concepts
- refinement
- plus operator
- view refinement
- explore refinement
- ordering
- modular LookML
Extends & Abstract Views
Extending views and explores, extends vs refinements, abstract views with extension: required, DRY patterns in LookML, and inheritance hierarchies
Objectives
- Create reusable LookML components using extends and abstract views
- Choose between extends and refinements for different modeling needs
Key concepts
- extends
- extension: required
- abstract view
- DRY
- inheritance
- code reuse
Derived Table Concepts
Introduction to derived tables, when to use derived tables vs database views, ephemeral vs persistent derived tables, and performance trade-offs
Objectives
- Determine when derived tables are appropriate vs native database objects
- Understand the trade-offs between ephemeral and persistent derived tables
Key concepts
- derived table
- ephemeral
- persistent
- database view
- performance
- use cases
Data Tests
LookML data tests for validating model assumptions, test syntax, assert conditions, explore_source for test queries, and CI/CD integration with Spectacles
Objectives
- Write data tests to validate LookML model correctness and data quality
- Integrate data testing into CI/CD pipelines using Spectacles or similar tools
Key concepts
- data test
- assert
- explore_source
- Spectacles
- CI/CD
- model validation
3 · Derived Tables & PDTs4 topics
Native Derived Tables
Building derived tables using Looker's native explore_source syntax, selecting fields, applying filters, sorting, and binding to views without writing SQL
Objectives
- Build native derived tables using explore_source to avoid raw SQL
- Map native derived table columns to view dimensions and measures
Key concepts
- explore_source
- native derived table
- column mapping
- filter binding
- no-SQL modeling
- field selection
SQL Derived Tables
Writing SQL-based derived tables, referencing other views with ${}, Liquid in derived table SQL, cross-database considerations, and testing SQL derived tables
Objectives
- Write SQL derived tables with proper view references and Liquid templating
- Test and validate SQL derived tables across different database dialects
Key concepts
- sql derived table
- view reference
- Liquid in SQL
- cross-database
- sql parameter
- testing
Persistent Derived Tables
PDT persistence strategies (datagroup_trigger, sql_trigger_value, persist_for), PDT rebuild scheduling, materialization in the database, and PDT monitoring
Objectives
- Configure PDT persistence strategies using datagroups and SQL triggers
- Monitor and troubleshoot PDT rebuilds in the Looker admin panel
Key concepts
- datagroup_trigger
- sql_trigger_value
- persist_for
- materialization
- rebuild scheduling
- scratch schema
Incremental PDTs
Incremental PDT configuration, increment_key and increment_offset parameters, append vs rebuild strategies, handling late-arriving data, and performance benefits
Objectives
- Configure incremental PDTs for large datasets to minimize rebuild time
- Handle edge cases like late-arriving data in incremental PDT strategies
Key concepts
- increment_key
- increment_offset
- append strategy
- late-arriving data
- incremental build
- performance
4 · Dashboards & Visualization4 topics
Dashboard Design
User-defined dashboards vs LookML dashboards, layout best practices, dashboard planning, responsive design, theming, and cross-explore dashboards
Objectives
- Design effective Looker dashboards following layout and UX best practices
- Choose between user-defined and LookML dashboards based on use case
Key concepts
- user dashboard
- LookML dashboard
- layout
- responsive design
- theming
- cross-explore
Tiles & Visualizations
Visualization types (table, bar, line, area, scatter, map, single value, funnel), tile configuration, merged results, custom visualizations, and conditional formatting
Objectives
- Select and configure appropriate visualization types for different data stories
- Use merged results and conditional formatting for richer dashboard tiles
Key concepts
- visualization types
- tile configuration
- merged results
- custom visualization
- conditional formatting
- drill
Dashboard Filters & Cross-filtering
Dashboard filter types, cross-filtering between tiles, filter-only fields, templated filters, always_filter on dashboards, and linked dashboards
Objectives
- Configure dashboard filters and cross-filtering for interactive analytics
- Implement filter-only fields and templated filters for flexible user exploration
Key concepts
- dashboard filter
- cross-filter
- filter-only field
- templated filter
- always_filter
- linked dashboards
Embedded Analytics
Looker embedding options (public, private, SSO embed), signed embed URLs, embed SDK (JavaScript/React), iframe embedding, and white-labeling embedded content
Objectives
- Implement SSO embedding with signed URLs and proper user attribute mapping
- Use the Looker Embed SDK for seamless integration into web applications
Key concepts
- SSO embed
- signed URL
- embed SDK
- iframe
- white-label
- embed user attributes
5 · Administration & Governance4 topics
User Management & Roles
Roles, permission sets, model sets, groups, user attributes, SAML/OIDC SSO, SCIM provisioning, and least-privilege access patterns
Objectives
- Design role-based access control using permission sets and model sets
- Configure SSO with SAML or OIDC for enterprise authentication
Key concepts
- roles
- permission sets
- model sets
- groups
- user attributes
- SAML SSO
Content Governance
Folder structure, content access control, look and dashboard management, content validation, System Activity explores, and usage tracking
Objectives
- Design folder structures with appropriate content access controls
- Use System Activity explores to monitor content usage and identify stale assets
Key concepts
- folders
- content access
- content validation
- System Activity
- usage tracking
- stale content
Database Connections
Connection configuration, PDT and temp schema settings, connection pooling, OAuth connections, SSH tunnels, and multi-database architecture
Objectives
- Configure database connections with proper security and performance settings
- Design multi-database architectures with connection-level isolation
Key concepts
- connection config
- PDT schema
- connection pooling
- OAuth connection
- SSH tunnel
- multi-database
Performance Optimization
Query performance analysis, caching strategies with datagroups, aggregate awareness, query limits, System Activity performance monitoring, and database tuning for Looker
Objectives
- Analyze and optimize query performance using caching and aggregate awareness
- Monitor instance health through System Activity performance explores
Key concepts
- query performance
- caching
- aggregate awareness
- query limits
- System Activity
- database tuning
6 · Advanced LookML & Extensibility4 topics
Liquid Templating
Liquid syntax in LookML, dynamic SQL generation, user attribute injection, conditional logic with {% if %}, Liquid variables, and security considerations
Objectives
- Write Liquid templates for dynamic SQL generation in LookML
- Implement security-safe Liquid patterns that prevent SQL injection
Key concepts
- Liquid syntax
- dynamic SQL
- user attributes
- conditional logic
- Liquid variables
- SQL injection prevention
Looker API
Looker REST API (4.0), SDK clients (Python, TypeScript, Go, Kotlin), scheduling via API, running queries programmatically, and API authentication
Objectives
- Use the Looker API and SDKs to automate common administrative tasks
- Run queries and manage content programmatically through the API
Key concepts
- REST API
- SDK
- API authentication
- run_query
- scheduled plans
- API explorer
Extensions Framework
Looker Extensions Framework for custom applications, React-based extensions, extension SDK, Marketplace extensions, and extension deployment patterns
Objectives
- Build custom Looker extensions using the Extensions Framework and React
- Deploy and manage extensions through the Marketplace or direct installation
Key concepts
- Extensions Framework
- React extensions
- extension SDK
- Marketplace
- deployment
- custom applications
Advanced LookML Patterns
Parameterized models, dynamic schema selection, access grants for row-level security, multi-tenant LookML architecture, project imports, and manifest files
Objectives
- Architect multi-tenant LookML projects with row-level security and dynamic schemas
- Use project imports and manifest files for cross-project code sharing
Key concepts
- parameterized models
- dynamic schema
- access_grant
- multi-tenant
- project import
- manifest
Levels: Junior, Mid, Senior, and Expert
Explain it in your own words
Graded by AI · no account · 1 questionNo options to guess from: you write, the AI grades against the topic's rubric and tells you what level your answer reads at.
Already studying Looker?
The assessment measures topic by topic, and your plan skips what you already know.
Open to read. An account is only needed to be measured.
Frequently asked questions
Where should I start studying Looker?
Start with LookML Fundamentals: LookML Views, Dimensions, and Measures. The map orders topics by what they depend on, so each one prepares the next.
How long does a full Looker assessment take?
A full assessment of this path takes about 45 minutes. Study time depends on where you start; a diagnostic shows which topics you can skip.
Do I need an account to use this page?
No. The map, objectives and key concepts are open. You only need an account to be measured, get your gap by topic and receive a plan.