Home/Skills
// Skills
Skills you can practice
Prepshotz teaches technical skills through hands-on, graded practice. SQL, Python, JavaScript, TypeScript, Java, C#, C++, Go and Ruby are live today: core language work in all nine, data analysis in SQL and Python, algorithms and data structures in Python, JavaScript, TypeScript, Java, C#, C++, Go and Ruby. You can also describe your own goal to get a track built around exactly that.
SQL
Query real databases, graded in your browser.
Practice the SQL that interviews and real analytics actually test - SELECT and WHERE, aggregations, HAVING, JOINs, window functions, subqueries and CTEs. You write queries against real datasets and they're graded by running them. Great for data-analyst and data-engineer interview prep.
-- rank products by revenue per category
SELECT category, name,
RANK() OVER (
PARTITION BY category
ORDER BY revenue DESC
) AS rnk
FROM products;A scripted preview. The real editor is in the app.
Python
Core Python and the data stack, graded by running it.
Core Python end to end - comprehensions, dicts and sets, closures, decorators, classes and dataclasses, generators, itertools and regular expressions. Then the data stack: numpy arrays and broadcasting, and the pandas work analysts live in - filtering, groupby, merges, pivots and dates. Algorithms and data structures run on the same loop, and everything executes on Pyodide in your browser, graded against a test suite. Good for data and backend interview prep.
# the three most common words
from collections import Counter
def top_three(text):
counts = Counter(text.lower().split())
return [w for w, _ in counts.most_common(3)]A scripted preview. The real editor is in the app.
JavaScript
The language of the web, run and graded for real.
Core JavaScript, including the parts that catch people out - closures and scope, this and prototypes, classes, iterators and generators, Map and Set, JSON and regular expressions. Async is covered properly: promises, async and await, error propagation, Promise.all and allSettled, microtask ordering. Algorithms and data structures are here too, and your code runs on QuickJS in your browser and has to pass a test suite. Good for front-end and full-stack interview prep.
// keep only the requests that settled
async function loadAll(urls) {
const settled = await Promise.allSettled(urls.map(load));
return settled
.filter((r) => r.status === "fulfilled")
.map((r) => r.value);
}A scripted preview. The real editor is in the app.
TypeScript
Types that have to compile before your code runs.
The same runtime ground as JavaScript - promises and async/await, iterators and generators, Map and Set, JSON, regular expressions, immutable updates - written with types that have to hold. On top of it the type system gets a full run: unions and narrowing, discriminated unions and exhaustiveness, generics with constraints and inference, keyof and indexed access, mapped and conditional types, the utility types and satisfies, plus the algorithms and data structures ladder. The real TypeScript compiler typechecks your file under strict mode, then QuickJS runs it, so a type error fails before a test ever does. Good if you already ship TypeScript and want the types to stop being decoration.
// narrow on the tag, then the value is typed
type Result =
| { ok: true; value: number }
| { ok: false; error: string };
function unwrap(r: Result): number {
if (r.ok) return r.value;
throw new Error(r.error);
}A scripted preview. The real editor is in the app.
Java
Real Java, compiled by javac in your browser.
Core Java as it is actually written - classes, interfaces, records, enums and sealed types, generics with bounds and wildcards, the collections framework, streams and collectors, Optional, lambdas and method references, exceptions and try-with-resources. Algorithms and data structures go from two pointers and heaps to trees, graphs, dynamic programming and backtracking. Your file is compiled by javac and translated to WebAssembly by TeaVM, so it really runs in the tab, and a test suite grades it. Good for coursework and for the interviews that still specify Java.
// rank by score, then break ties by name
static List<Player> ranked(List<Player> players) {
return players.stream()
.sorted(Comparator.comparingInt(Player::score).reversed()
.thenComparing(Player::name))
.toList();
}A scripted preview. The real editor is in the app.
C#
Modern C# and LINQ, compiled by Roslyn in your browser.
C# as it is written today, sharp edges included - records and structs, interfaces and generics with constraints, pattern matching with property and list patterns, switch expressions, nullable reference types, iterators, spans and ranges, and the collections from List and Dictionary to SortedSet and PriorityQueue. LINQ gets a run of its own: Select and Where, deferred execution, SelectMany, GroupBy, ordering and aggregation. Algorithms and data structures are covered too, so it works for .NET interview prep as much as for coursework. Roslyn compiles your code on the .NET WebAssembly runtime and a test suite grades it.
// total each city's orders
public static Dictionary<string, int> Totals(Order[] os) =>
os.GroupBy(o => o.City)
.ToDictionary(g => g.Key, g => g.Sum(o => o.Amount));A scripted preview. The real editor is in the app.
C++
Modern C++, compiled by clang in your browser.
C++ from the ground it actually stands on - values and auto, references and const correctness, pointers and nullptr, strings and string_view, vectors and the rest of the containers, iterators and the half-open range. Then the parts that decide whether C++ code is right: RAII, the rule of five, move semantics, unique_ptr and shared_ptr, templates and concepts, virtual functions and object slicing, and the STL algorithms with lambdas over them. Algorithms and data structures run the same ladder, from two pointers and monotonic stacks to trees, graphs and dynamic programming. Your file is compiled by clang and linked by lld - both of them WebAssembly running in the tab - into a standalone module, and a test suite grades it. Good for coursework and for the interviews that still specify C++.
// the names that cleared the bar, in order
vector<string> passing(const vector<Result>& rs) {
vector<string> out;
for (const auto& r : rs)
if (r.score >= 60) out.push_back(r.name);
sort(out.begin(), out.end());
return out;
}A scripted preview. The real editor is in the app.
Go
Real Go, compiled by Go's own toolchain in your browser.
Go as it is actually written: slices and their length-versus-capacity trap, maps and the comma-ok form, structs and methods, interfaces satisfied implicitly, errors as values and the wrapping that goes with them, and generics where they earn their place. Then the part Go is hired for - goroutines, channels, select and sync - drilled only on answers that do not depend on which goroutine wins, so a pass means the code is right rather than lucky. Algorithms and data structures run the same ladder. Your file is compiled and linked by Go's OWN cmd/compile and cmd/link, both running as WebAssembly in the tab, so the compiler that judges you is the one you would run at your desk.
// the names that cleared the bar, in order
func Passing(rs []Result) []string {
out := []string{}
for _, r := range rs {
if r.Score >= 60 {
out = append(out, r.Name)
}
}
sort.Strings(out)
return out
}A scripted preview. The real editor is in the app.
Ruby
Idiomatic Ruby, run by CRuby itself in your browser.
Ruby the way Ruby is written, not Python with end. Blocks and yield, procs against lambdas, and the Enumerable methods that replace most loops: each_with_object, group_by, tally, partition and filter_map. Then the things Ruby is actually hired for - modules and mixins, include against extend against prepend and the method lookup that follows, symbols as identity, and pattern matching. Algorithms and data structures run the same ladder, and the in-place methods get their own drills because a sort! that returns a copy is the bug an interviewer looks for. Your code is run by CRuby itself, built to WebAssembly - the same interpreter, not a lookalike.
# the names that cleared the bar, in order
def passing(results)
results
.select { |r| r[:score] >= 60 }
.map { |r| r[:name] }
.sort
endA scripted preview. The real editor is in the app.
// Also in the catalog
Beyond the nine languages.
The classics in Python, JavaScript, TypeScript, Java, C#, C++, Go or Ruby, graded by tests.
Start practicing →// The engine
Describe your own goal.
Type what you want to get good at - "window functions for a data-analyst interview"- and get a hands-on, graded track built around exactly that, that adapts as you go. This is live today.
Each account can build 5 of these tracks while we are in beta, and a track cannot be deleted afterwards, so pick your goals with care. The curated ladders above are unlimited.