How I started coding in college and cracked my first software developer job 👩‍💻 #job #viral #coding

Main ideas / concepts (key lessons)

• Started without real coding knowledge until late in college: The speaker says they didn’t truly understand coding until third year.
• Problem was understanding “internal flow,” not memorizing theory: They could explain definitions (e.g., array/string) and had theoretical clarity, but they couldn’t understand how code works step-by-step or the flow of implementation.
• Video tutorials alone weren’t enough: They watched many YouTube tutorials multiple times but still couldn’t get clarity or consistency in learning.
• A turning point came from structured college training: In the last semester of third year, a training/placement coordinator (“sir”) taught concepts with correct internal flow, which made coding click.
• Structured practice + curated topic focus for placements: The training included daily concept-building first, then heavy practice, plus assignments/questions aligned with what companies ask.
• Confidence came from repetition and approaches: Even without being a complete master, they built confidence that they understood approaches and wouldn’t be “blank” during interviews.
• Placement journey included multiple failures before success:
  • They didn’t get selected in the first two companies (mainly due to aptitude and also lack of technical progress in those rounds).
• Success came in the third company, aided by practice + some luck: Familiar questions from what they had studied helped them pass multiple rounds (including technical rounds).
• Advice to viewers:
  • Clear basics first (don’t jump to “advanced” too early).
  • Practice daily with interview-style questions.
  • Strengthen core concepts (especially OOPs).
  • Use a curated question list from the training (they offer to share it/tag it if needed).

---

Methodology / “what to do” (detailed bullet points)

How they learned coding effectively

Before training (what didn’t work)

• Read theoretical subjects and could explain terms.
• Memorized concepts like what arrays/strings are.
• Watched coding tutorials multiple times, but:
  • Couldn’t understand how implementations flow.
  • Was not consistent.
  • Still lacked internal understanding.

During training (what worked)

• Attended a coding class from 10:00 am to 4:00 pm.
• Training lasted about 1 month.
• Daily structure:
  • First hour: instructor explained concepts and internal flow (how things work, not just definitions).
  • Then practice: lots of questions in class.
  • Self-practice after class: instructor assigned more placement-level questions.
• They practiced with juniors and helped check understanding.

What they practiced for interviews / campus placement

Focused on common data structures and interview topics:

• Array
• String
• Stack
• Queue
• Trees / tree-related topics (mentioned generally)
• HashMap / hash map topics (mentioned)
• Linked List
• “View” (unclear/possibly a mis-transcription)
• Connections/graph-like topics (unclear transcription; likely graphs)

They practiced enough problems to know approaches, not just final answers.

How they approached placements after learning

They recognized a typical interview pipeline:

• Round 1: Aptitude (they failed this in early companies)
• Round 2: Sometimes aptitude + technical (they also didn’t clear this early on)
• Round 3 / later rounds: Technical rounds; in the successful company, they cleared these.

They built confidence by:

• Solving previous questions again after failing earlier rounds.
• Using prior practice to reduce “blankness” during interviews.

Final preparation advice they gave

1. Clear basics first (don’t go “advanced” prematurely).
2. Keep concepts clear—OOPs are frequently asked.
3. Practice daily with interview-type questions.
4. Use a curated practice list provided by the “sir”:
   • They suggest sharing/tagging the link if needed.
   • Even if some questions go beyond the list, practice them once anyway.
5. Learn “advanced” later, after basics and core topics are strong.

---

Narrative arc (chronological)

1. Up to third year: theoretical understanding, but no real coding/internal flow understanding; tutorials didn’t help much.
2. Last semester of third year: college training by a visiting “sir” was the turning point.
3. Training month: structured daily concept + practice; assigned placement-level questions.
4. First two campus companies: failed aptitude (and did not reach technical success).
5. Third company: luck + familiarity with studied questions; passed second round and subsequent rounds.
6. Result: got first job as a software developer; they emphasize the journey wasn’t perfect and they didn’t know Spring Boot earlier.

---

Speakers / sources featured (as identifiable in the subtitles)

• Primary speaker: The narrator (a woman speaking about her own coding journey).
• “Sir” / instructor / placement coordinator: The visiting trainer from the college who ran the training and gave a practice question plan.
• Kajal: Mentioned as the person who contacted/called the speaker for the next round and later confirmed placement.
• CEO: Asked technical questions in one of the later interview rounds.
• Other interviewers/seniors: One interview round was taken by a “senior” (no name given).
• YouTube (source): The speaker references watching tutorial videos on YouTube.
• Campus placement companies (multiple): Three companies mentioned, but not named.