Skip to content
NectArray
Applications open

Welcome to
NectArray Academy

Python, SQL and data science — taught live, in a group where we read every line you write.

A placement programme for people moving into data science and AI. Python first, then SQL, then the interview and portfolio work that decides who gets the offer. You practise in every session instead of watching lectures.

Sign in, and the dashboard opens with your notes, the practice and your progress in it.

Flagship programme

Taught live.
One focused group.

Duration
12 weeks
Format
Live online, hands-on
Commitment
6–8 hrs / week
Group size
Capped by design

About the course

You write the code. Someone who does it for a living reads it.

You write code in every session, someone who ships code for a living reads it, and you are told plainly what to fix. That loop is the whole programme.

The order is deliberate. Python first, because everything downstream assumes it. SQL second, because the job is mostly asking data questions and the people who can do that cleanly are rarer than you would think. Then the part that actually converts skill into an offer — how the industry is structured, what a résumé is scanned for, and what happens in a technical round.

It is built for the two people who keep asking us for it: someone starting out in data science or agentic AI who wants a solid floor to stand on, and someone already working who wants to switch fields and be interview-ready without quitting their job first.

The full syllabus, week by week ↓

What you leave with

  • Write Python you would be willing to show an interviewer
  • Query and reason about relational data without reaching for a tutorial
  • Solve array, string and dictionary problems under time pressure
  • Walk into a technical round knowing what is actually being assessed
  • Leave with a project, a portfolio and a written career roadmap

Who it is for

  • Graduates targeting data, analyst and AI-adjacent roles
  • Working professionals switching domain without quitting first
  • Anyone planning to move into data science or agentic AI who wants a floor under them

Curriculum

The whole programme, in order.

Python first because everything assumes it, SQL second because the job is mostly asking data questions, then the part that turns both into an offer.

Python Core & Advanced22 days10 topicsFrom what a program even is, through to threads, async and a capstone you can talk through in an interview.
  • Programming FundamentalsLanguages, compilation vs interpretation, Python architecture, installation, IDEs.
  • Python BasicsVariables, data types, operators, type conversion, input/output.
  • Conditions & Loopsif/elif/else, match, for, while, break, continue, pass, patterns.
  • Strings & ListsIndexing, slicing, methods, formatting, comprehensions.
  • Tuples, Sets & DictionariesMethods, operations, nested collections.
  • FunctionsParameters, arguments, scope, lambda, recursion, built-in functions.
  • File & Exception HandlingFiles, context managers, try/except, custom exceptions.
  • Object-Oriented ProgrammingClasses, objects, inheritance, encapsulation, polymorphism, abstraction.
  • Advanced PythonModules, packages, virtual environments, memory management, threads, multiprocessing, async.
  • Revision, Practice & CapstoneReal interview questions, problem-sheet practice and a mini project.
SQL & Relational Databases18 days11 topicsTaught in MySQL 8. Every query in the notes was executed before it was written down, and the outputs are the real ones.
  • Database FundamentalsDBMS, RDBMS, SQL, database design, SQL execution flow.
  • Database ObjectsCREATE, ALTER, DROP, TRUNCATE, constraints, data types.
  • SELECT QueriesSELECT, WHERE, ORDER BY, DISTINCT, LIMIT, aliases, expressions.
  • Operators & ClausesComparison, logical, IN, BETWEEN, LIKE, EXISTS, ANY, ALL.
  • SQL FunctionsString, numeric, date, aggregate and conditional functions.
  • GroupingGROUP BY, HAVING, aggregations and the real execution order.
  • Joins & Set OperationsINNER, LEFT, RIGHT, FULL, SELF joins and UNION.
  • Subqueries & Window FunctionsSubqueries, ROW_NUMBER(), RANK(), DENSE_RANK().
  • Views, Indexes & TransactionsViews, indexes, transactions — COMMIT, ROLLBACK, SAVEPOINT.
  • PL/SQL FundamentalsBlocks, variables, loops, procedures, functions, triggers.
  • Revision & Interview PrepRevision, real-world queries and complex interview questions.
Data Science & Agentic AI11 days11 topicsThe half teams are hiring for: pandas and models first, then agents that retrieve, remember, call real tools and get judged against an evaluation set.
  • NumPy and pandasArrays, DataFrames, vectorised thinking, grouping and joining — the two libraries everything else sits on.
  • Cleaning real dataWrong types, ambiguous dates, near-duplicate text, missing values, and the checks that catch each of them.
  • Machine learning in one passscikit-learn's four methods, honest splits, pipelines that prevent leakage, and choosing a metric you can defend.
  • Deep learning, NLP and embeddingsNetworks and transformers briefly; tokens and embeddings properly, because everything after this depends on them.
  • What an agent actually isThe loop, tool definitions as prompts, and the five ways agents fail in production.
  • Retrieval-augmented generationChunking, embeddings, pgvector, hybrid search, reranking, citations, and measuring recall rather than eyeballing it.
  • LangChain and LangGraphChains where a line is enough; state, nodes, edges, checkpointers and human-in-the-loop where it is not.
  • Memory, sessions and usersWorking, session and long-term memory as three separate problems, with the context budget they have to fit.
  • MCP — the Model Context ProtocolTools, resources and prompts; stdio and Streamable HTTP; writing a server, and the security that goes with one.
  • The framework landscapeLangGraph, OpenAI Agents SDK, Vercel AI SDK, AutoGen, Semantic Kernel, Azure AI Foundry — and when each earns its place.
  • Shipping an agentEvaluation sets, guardrails, retries, cost control, observability and streaming — the work that makes a demo a product.
Placement Readiness & Career Strategy5 days5 topicsThe part that turns everything you have learned into an offer, and the part most people are missing when they start applying.
  • Software Engineering & SystemsSDLC, processes, job roles, team structure, system design basics.
  • Profile BuildingRésumé building, ATS optimisation and GitHub portfolio strategy.
  • Outreach & StrategyLinkedIn optimisation, job portals and strategic job-search workflows.
  • Behavioural ReadinessSelf introduction, professional communication and HR interview preparation.
  • Evaluation & RoadmapTechnical mock interview, structured feedback and a personalised career roadmap.

Exclusive course offerings

Our Offerings

Seven things a live class of five makes possible, every session, for every person in the room.

  • Live, interactive sessions

    Every class is taught live, in a group of five, and you are meant to interrupt it. You ask the moment a question comes up, your code is reviewed on screen while the session is running, and the room sets the pace — that back-and-forth is where the learning actually happens. Every session is recorded, so you can go back over any of it afterwards.

  • Assignments read and scored

    Submit your solution and get it back scored out of ten on correctness, readability and whether it would survive a code review — with the specific lines that cost you the marks named, not a grade and a shrug. Fix them and you can resubmit once.

  • A SQL playground in the browser

    Questions ordered easy to hard against a real database you query in the page. Write it, run it, see the rows, and find out straight away whether it matches — you are checked on what your query actually returns, not on how it is worded. It runs in the browser, so you are querying within a minute of arriving.

  • Interview-focused Python practice

    Arrays, strings and dictionaries — the interview core — ordered easy to hard. Every problem is written out in the portal and judged the way a screen judges: hidden tests, pass or fail. It is built around the patterns screens actually ask for, so every hour you put in is an hour that counts.

  • Documentation-grade notes

    Every session has written notes with runnable examples and the real output printed beside them — run before it was written down, so nothing in there is what we assumed the answer would be. They are yours to keep, and they are written to be the reference you still open in your first job.

  • Agentic AI, the part teams hire for

    The last stretch goes past analysis into what teams are hiring for now. You build a retrieval agent over a real document set, wire one to tools it can actually call, and then judge it against an evaluation set rather than on whether the demo felt right.

  • Placement preparation built in

    Résumé and ATS, a GitHub portfolio worth linking to, LinkedIn and outreach that actually gets replies, and the HR rounds nobody prepares for. It ends on a technical mock interview with structured written feedback.

FAQs

The questions we actually get.

  • Do I need to know how to code already?

    No. It starts at what a programming language is. What you do need is the 6–8 hours a week — the programme is paced for someone doing the practice, and it does not work as something you watch.

  • Are the classes live?

    Yes — every session is taught in real time, in a group of five, and you are expected to interrupt it. You get your own mistake looked at while you still remember what you were thinking. Sessions are recorded afterwards too, so a class you cannot make is still there to catch up on.

  • Why so few places?

    Because every assignment is read individually and scored with specific feedback. That does not scale, and we would rather run more groups than dilute one.

  • How are assignments assessed?

    You submit your solution and get it back scored out of ten — on whether it is correct, whether it is readable, and whether it would survive a review. You see which lines cost you marks, not just a number.

  • What are the notes, exactly?

    A written reference for every topic we cover, kept in your dashboard rather than handed out as slides. Each one has the explanation, a worked example with its output beside it, and practice questions at the end. They are edited as the course runs — if a session throws up a better way to explain something, the note is updated that week and you see the new one.

  • What is the practice environment?

    A SQL playground and a Python judge that run in the browser, with no setup on your machine. You write a query or a function, run it against real tables or hidden test cases, and get told what failed and why. Your solved questions are tracked, so you can see what you have actually covered rather than what you have read.

  • Do I keep any of it afterwards?

    Yes. Your login stays, so the notes and the practice environment stay with you — including the updates made after your cohort finishes. The programme ends with a technical mock interview and a written roadmap specific to where you are and what you are targeting.