How I Learned to Code Well Enough to Get Paid in 6 Months

Not a "anyone can code" post. This is what actually worked for me — and what didn't.

Where I Started (Month 0)

• Zero coding experience
• Full-time job (not in tech)
• 2 hours/day available for learning
• Budget: $0 (free resources only)
• Goal: Get paid to write code within 6 months

Spoiler: I made it. But not the way you think.

The Plan That Failed

Month 1: Tutorial Hell

I did what everyone does:

1. Watched 47 YouTube tutorials
2. Completed 3 Codecademy courses
3. Read half of "JavaScript: The Good Parts"
4. Built a calculator app (that nobody needed)

Result: I knew syntax but couldn't build anything real.

The problem? Tutorials teach you to follow. Nobody pays you to follow instructions.

Month 2: The Portfolio Trap

"Build projects!" they said. So I built:

• A to-do list app (10,000 other people have this)
• A weather widget (uses free API)
• A personal website (nobody visited)

Result: GitHub green squares looked nice. Still $0 income.

Projects without users aren't impressive to employers or clients.

What Actually Worked

Pivot: Stop Learning, Start Solving

Month 3 was when everything changed. I stopped "learning to code" and started solving problems with code.

The difference:

Learning Mode	Solving Mode
"How do I write a for loop?"	"I need to process 1000 records"
Watching a tutorial	Reading documentation
Building toy apps	Fixing real problems
Following along	Getting stuck and unstuck

Step 1: Find a Problem You Actually Have

My problem: I spent 2 hours every day doing repetitive tasks at work:

• Copying data between spreadsheets
• Sending similar emails to clients
• Checking multiple websites for updates
• Formatting reports the same way every week

This was my goldmine. Each task was automatable.

Step 2: Build the Ugly Solution First

# My first automation script — it was UGLY
import openpyxl
import smtplib
from email.mime.text import MIMEText

# Read spreadsheet
wb = openpyxl.load_workbook('clients.xlsx')
sheet = wb.active

# For each row, send an email
for row in sheet.iter_rows(min_row=2):
    name = row[0].value
    email = row[1].value

    msg = MIMEText(f'Hi {name}, here is your weekly report...')
    msg['Subject'] = f'Weekly Report - {name}'
    msg['From'] = '[e-mail]'
    msg['To'] = email

    # Send email (this is terrible practice, don't do this)
    server = smtplib.SMTP('smtp.gmail.com', 587)
    server.starttls()
    server.login('myemail', 'mypassword') # Hardcoded password!
    server.send_message(msg)
    server.quit()

print(f'Sent {sheet.max_row - 1} emails')

It worked. It saved me 90 minutes per week. It was also security nightmare code.

But here's the key insight: It solved a real problem. That's worth more than beautiful code that does nothing.

Step 3: Make It Less Ugly (Iterate)

Week by week, I improved:

# Week 3: Load credentials from .env file
from dotenv import load_dotenv
load_dotenv()

# Week 4: Add error handling
try:
    send_email(client_data)
except Exception as e:
    log_error(e)
    notify_admin(str(e))

# Week 5: Add logging
logger.info(f'Processing {client_name} ({client_email})')

# Week 6: Make it configurable via YAML config file
# Week 7: Add CLI arguments
# Week 8: Package as installable tool

Each iteration taught me more than any tutorial. Because each bug was MY bug, in MY code, solving MY problem.

Step 4: Show People

I didn't wait until it was perfect. After week 4, I showed my manager:

"I automated the weekly report emails. It used to take me 2 hours. Now it takes 5 minutes."

His response: "Can you automate the monthly invoices too?"

That was my second project. Then the third. Then I became "the automation guy."

Step 5: The Leap to Getting Paid

After 6 months of this:

1. I had 12 working scripts/tools
2. My team relied on them daily
3. I could build things end-to-end
4. I had a portfolio of REAL solutions (not tutorial projects)

I applied for a junior developer role. Not because of my degree (I don't have one). Not because of my GitHub (it was mostly private). Because I could demonstrate that I solve problems with code.

The Skills That Mattered Most (In Order)

Skill	When I Needed It	How I Learned
Problem decomposition	Day 1	Practice
Google-fu / Reading docs	Day 1	Necessity
Basic scripting	Week 1	Official docs + trial/error
Error handling	Week 2	Breaking things on purpose
Git basics	Week 3	Real project necessity
Data formats (JSON/CSV)	Week 2	Working with real data
API usage	Week 4	Documentation
Testing	Week 6	After a script broke production
Code organization	Week 8	Refactoring messy scripts
Database basics	Month 4	Outgrew CSV files

Notice what's missing: algorithms, data structures, design patterns, computer science fundamentals.

I still don't know most of that stuff. And I get paid to write code.

What I'd Do Differently

Start With JavaScript, Not Python

Python is great. But JavaScript opens doors to:

• Web development (biggest job market)
• Browser automation (like my current work)
• Full-stack opportunities
• Higher average salaries

Python kept me in scripting land. JavaScript would have gotten me to web apps faster.

Build in Public Earlier

I waited too long to share what I was building. My first tweet about my automation work got 50+ likes and 2 job inquiries.

People pay for visible expertise. If you can show your work, opportunities find you.

Charge Money Sooner

I did free work for 4 months before realizing people would pay for these same automations. My first freelance client paid $200 for a script I'd built for free at my job.

If someone finds value in what you built, charge them for it.

The 6-Month Timeline (Reality)

Month	What I Did	Income
1	Tutorials + toy projects	$0
2	More tutorials + portfolio	$0
3	First automation (saved time)	$0 (but saved 8hrs/week)
4	3 more automations at work	$0 (became invaluable at work)
5	First freelance gig ($200)	$200
6	Junior dev job offer ($55k/yr)	$0 → salary

Total investment: ~300 hours over 6 months
Return: $55,000/year starting salary + $200 freelance

Resources That Actually Helped (Free)

Resource	Best For
MDN Web Docs	JavaScript reference (best docs anywhere)
Stack Overflow	Specific questions (read, don't just ask)
GitHub Issues	Seeing how real projects solve problems
Official library docs	Learning APIs properly
Exercism.io	Practice problems (free, community-reviewed)
Dev.to articles	Real-world patterns from developers
YouTube (selectively)	Traversy Media, Fireship (not tutorials — builds)

Resources That Wasted My Time

Resource	Why It Didn't Work
Long video courses (>5 hours)	Passive watching ≠ learning
"Learn X in Y days" books	Rushed, no retention
Copy-pasting tutorial code	No understanding
Comparing languages/frameworks	Analysis paralysis
Reading about best practices	Can't apply what you haven't done yet

Advice to My Past Self

1. Build 10 ugly things before you build 1 pretty thing. Ugly but working > pretty but broken.
2. Show your work from day one. Tweet it, blog it, put it on GitHub.
3. Don't call yourself a "junior." Call yourself a developer who's early in their journey.
4. Specialize in solving ONE type of problem. Become known for that.
5. Talk to humans. Most coding jobs come from conversations, not applications.
6. Charge for your work. Even if you feel underqualified. They're paying for the solution, not your resume.

The Unpopular Opinion

You don't need:

• A CS degree
• To know algorithms
• To contribute to open source
• To have a perfect GitHub profile
• To be "ready"

You DO need:

• The ability to solve problems with code
• Evidence that you've done it
• The confidence to say "I can figure this out"
• Basic professionalism (shows up, communicates, delivers)

Everything else you learn on the job. That's what the job IS — learning while doing.

---

Where are you on your coding journey? Drop a comment — let's compare notes.

Follow @armorbreak for more honest developer content.