You’ve applied to fifty jobs and heard nothing back. Your skills are probably fine. Your resume is losing in the first few seconds. An eye-tracking study by the job site Ladders found recruiters spend about seven seconds on a first look, and at many large companies an applicant tracking system (ATS) reads your resume before any human does.

I built a free resume builder with 12 ATS-friendly templates for freshers and experienced developers, and wrote the rules below into it. It checks your bullets as you type. Here’s what it checks, and why.

Rule 1: Simple beats pretty

An ATS reads plain text. Two-column designs, text inside images and star-rating skill bars can come out scrambled. Use one column, normal fonts and real text. And use the exact words from the job post: if it says Spring Boot, don’t write only Spring.

Rule 2: Write every bullet with the XYZ formula

Laszlo Bock, who led hiring at Google, shared a simple formula: accomplished X, as measured by Y, by doing Z.

• Before: “Responsible for backend APIs.”
• After: “Cut API response time by 40%, from 500 ms to 300 ms, by adding Redis caching.”

No exact number? Use a fair estimate, a count or a scale: users, requests per day, hours saved, bugs closed. Then start with a strong verb: built, cut, led, shipped.

Rule 3: Get the layout right

• Header: name, city, phone, email, LinkedIn, GitHub. No photo or date of birth for big-tech roles.
• Summary: two lines, with your years, your strongest skill and one result.
• Experience: newest first, 3 to 5 XYZ bullets per job.
• Skills: grouped into languages, frameworks and tools. No star ratings.
• Length: one page if you have under about ten years of experience.

5 mistakes that get resumes rejected

• Typos. Read it out loud, one line at a time.
• Duties instead of results (“worked on”, “involved in”).
• One resume for every job. Tweak the summary and skills each time.
• Every tool you’ve ever touched. If you can’t answer two questions on it, cut it.
• A file called resume_final_FINAL2.docx. Send a PDF named with your name.

Fresher? Your projects are your experience

Put education near the top, then projects written with the same XYZ bullets. “Made a to-do app” is weak; “Built a to-do API in Spring Boot with JWT login, used by 200 people” is strong. Add checkable numbers like your LeetCode count and a GitHub link. If you’re preparing for coding rounds too, the free DSA in Java course and its 352-problem practice sheet are a good place to start.

Build yours free

The Compiled Canvas resume builder has 12 templates, a Fresher/Experienced switch, live suggestions on every bullet, and PDF or Word download. Everything stays in your browser; nothing is uploaded and there’s no sign-up. The resume guide has more before-and-after examples, and the LinkedIn guide has a headline maker for your profile.

📝 Open the free resume builder
🔔 Subscribe to Compiled Canvas for the full resume and LinkedIn video lessons.

Originally published at https://compiledcanvas.com.

Everyone uses ChatGPT. Very few people can explain what happens between pressing Enter and seeing the answer. That gap matters: once you understand tokens, context windows and temperature, you write better prompts, pick cheaper models, and stop being surprised when a chatbot “forgets” or makes something up.

This is a free course I’m building on YouTube, Generative AI with Python. Each lesson is short, uses everyday pictures, and has small Python programs you can run from the lesson pages on compiledcanvas.com. Here are the first six.

Lesson 1: What is generative AI?

AI, machine learning, deep learning and generative AI aren’t four separate things. They’re four circles, each inside the last. AI is any machine doing something that looks smart. Machine learning learns patterns from examples instead of hand-written rules. Deep learning does that with many-layered neural networks. Generative AI is the deep learning that creates new text, images or code.

▶ Watch lesson 1 · Read the lesson page

Lesson 2: How LLMs work

A large language model never sees your words. It sees numbers. Text is cut into tokens (100 tokens is about 75 English words), each token becomes an embedding (a list of numbers where similar meanings sit close together), and the model scores every possible next token. It picks one, adds it to the text, and asks again. That’s it: next-token prediction, one token at a time.

▶ Watch lesson 2 · Run the Python tokenizer and softmax

Lesson 3: Transformers and attention

“The animal didn’t cross the street because it was too tired.” You know “it” means the animal. For a computer that’s hard, and the 2017 paper Attention Is All You Need solved it. Each word scores every other word for relevance, using a query, a key and a value, a bit like a YouTube search. Because every word is processed at once, transformers train fast on GPUs.

▶ Watch lesson 3 · Build attention in Python

Lesson 4: Open vs closed models, reasoning and multimodal

Closed models (GPT, Claude, Gemini) run on the company’s servers and you pay per use. Open-weight models you can download and run yourself. Reasoning models think before answering: slower and pricier, better at maths and code. Multimodal models take images and audio. The lesson ends with a simple way to choose.

▶ Watch lesson 4 · Read the lesson page

Lesson 5: Context window, temperature and cost

Why does your chatbot forget? Its context window is a whiteboard: only what fits on it is seen, and old text falls off. Temperature is the randomness dial: low for facts and code, higher for brainstorming. And you pay for tokens in and tokens out, so pasting a huge document every turn gets expensive fast.

▶ Watch lesson 5 · Try the temperature demo

Lesson 6: The 5 parts of a great prompt

Vague in, vague out. A strong prompt has five parts: a role (who it should be), instructions (one clear job), context (what it can’t know), examples (show what good looks like) and an output format (bullets, JSON, a table). And give it a way out: tell it to say “I don’t know” when it isn’t sure.

▶ Watch lesson 6 · Use the prompt builder

What’s next

• Zero-shot, few-shot and chain-of-thought prompting.
• Calling an LLM API from Python, then building a chatbot.
• RAG: making an AI answer from your own documents.
• AI agents that use tools.
• Each lesson also has a 1-minute Web Story with a quiz.

▶ Watch the full Generative AI playlist on YouTube
🔔 Subscribe to Compiled Canvas for a new lesson every week.

Originally published at https://compiledcanvas.com.

Most people who quit DSA don’t quit because it’s hard. They quit because they study it in a random order. They watch a dynamic programming video on Monday, a graphs video on Wednesday, and by Friday nothing connects.

I’m a Java developer with 11 years in the industry, and I’m building the course I wish I’d had: DSA in Java, from zero, in the right order. Every lesson is a short video with pictures and graphs instead of heavy theory, plus a free practice page with LeetCode problems, hints and Java solutions on compiledcanvas.com.

Here are the first 10 lessons, what each one teaches, and the one idea from each you should walk away with.

1. Start with the roadmap

Before any code: what to learn, in what order, and how long each part takes. The short version is Big O first, then arrays and strings, then hashing, recursion, linked lists, stacks, trees, graphs and finally dynamic programming. Practise 3 to 5 problems per pattern instead of 500 random ones.

▶ Watch: DSA Roadmap 2026 · See the full 26-topic roadmap and practice sheet

2. Big O: why two correct programs aren’t equal

Two programs can give the same answer, and one takes a second while the other takes hours. Big O is how you tell them apart before you run anything. O(1) is one step. O(log n) halves the work each step, so a million items need about 20. O(n) is one loop. O(n²) is a loop inside a loop, and that’s where solutions time out.

Big O drops constants. 3n + 5 is just O(n).

▶ Watch: Big O Notation Explained Simply · Practise: complexity problems

3. Calculating complexity of any code

Once you know the shapes, four rules cover almost every snippet: nested loops multiply, loops in a row add, a counter that doubles or halves is log n, and for recursion you multiply the number of calls by the work per call. The video walks through tricky cases like an outer loop that doubles with an inner loop that runs n times. That’s O(n log n), not O(n²).

▶ Watch: How to Calculate Time Complexity of Any Code

4. The Java you actually need for DSA

Your logic can be perfect and Java can still fail your code. Two Integer objects holding 1000 are not == to each other. An int sum quietly overflows past 2.1 billion and turns negative. Building a string with + inside a loop is secretly slow. This lesson covers ArrayList, HashMap, HashSet and ArrayDeque, and the traps that fail real interviews.

▶ Watch: Complete Java for DSA · Practise: Java basics problems

5. The only math you need

Checking if a billion is prime by looping to n takes a billion steps. Stopping at the square root takes 31,623. That’s the flavour of math in coding interviews: primes, the Sieve of Eratosthenes, GCD with Euclid’s trick, and taking answers modulo 1⁰⁹ + 7. One Java gotcha: −7 % 3 is −1, not 2.

▶ Watch: Basic Math for DSA · Practise: math problems

6. Bit manipulation

Every number appears twice except one. Find it. Most people reach for a HashMap. XOR every number together instead: pairs cancel out (x ^ x = 0) and the single number is left, in O(1) extra memory. The lesson builds AND, OR, XOR and shifts from scratch, plus the classic tricks like n & (n − 1) for powers of two.

▶ Watch: Bit Manipulation from Scratch · Practise: bit problems

7. Arrays, properly

Why is reading arr[999999] one step, but inserting at the front a million? Because Java jumps straight to an address, but inserting shifts every value one seat to the right. This lesson uses lockers and cinema seats to make arrays obvious, and ends with reversing an array in place with two pointers.

▶ Watch: Array Data Structure in Java · Practise: array problems

8. Prefix sum: any range sum in one step

Build an array of running totals once, in O(n). After that, the sum of any range L to R is prefix[R + 1] − prefix[L], one subtraction. It’s the trick behind a whole family of LeetCode problems. The most common mistake is forgetting that +1.

▶ Watch: Prefix Sum Explained · Practise: prefix sum problems

9. Two pointers: five patterns

Two indexes instead of two nested loops. Opposite ends for palindromes and pair sums in a sorted array; slow and fast pointers to remove duplicates in place. O(n) time, O(1) extra space. The video covers five patterns you’ll see again and again.

▶ Watch: Two Pointers in Java: 5 Patterns · Practise: two pointer problems

10. Sliding window

Don’t recompute every window from scratch. Add the number that enters, drop the one that leaves. Fixed windows keep size k; variable windows grow on the right and shrink on the left while a rule is broken. Shrink with while, not if.

▶ Watch: Sliding Window in Java · Practise: sliding window problems

How to use this course

• Watch one lesson a day, in order. Each is about 10 to 15 minutes.
• After each video, solve 2 or 3 problems from its practice page before reading the hints.
• Short on time? Tap through the 1-minute Web Stories for each lesson, with a quiz and a cheat sheet.
• New lessons come out every day: Kadane’s algorithm, Dutch National Flag, matrices, strings, KMP and more.

▶ Watch the full DSA in Java playlist on YouTube
🔔 Subscribe to Compiled Canvas so you don’t miss the next lesson.

Originally published at https://compiledcanvas.com.