Disclaimer:

I’m keeping the details of the programme vague on purpose. Most of the fun was walking in without knowing what was coming, and I don’t want to spoil that for the next batch. I’ll stick to what it was like to be there.

I first heard about Entelect at a jobs fair, where I got chatting to a few Entelectuals. I applied to their graduate programme afterwards, and that’s how I ended up at the Entelect bootcamp at the start of 2026 as a junior software engineer.

In the first week of January I flew up from Cape Town to Johannesburg, where I’d spend the next eight weeks.

Onboarding

Day zero was a small welcome ceremony at a convention centre in Melrose. The whole intake was in one room for the first time, everyone a bit awkward and trying to remember names. We did the induction, got walked through how the eight weeks would run, and then got our welcome packs:

welcome ceremony at the convention centre in Melrose welcome pack

The pack had a laptop, some Entelect merch and a notebook. The laptop was the big item, but the notebook was my favourite. Inside each one was a handwritten note from Shashi, our CEO, personalised for each of us. Mine said he hopes I get to go to an F1 race one day. If you’ve read my Ferrari post, you’ll know why that made my day.

Something else from day one stuck with me. We weren’t called grads, juniors or interns. We were Entelectuals, the same title as everyone else in the building. Yes, that’s really what we call ourselves, and no, it doesn’t take long to get used to.

Moving to Joburg

I’d never lived in Joburg before, or anywhere other than home for longer than a holiday. The accommodation was pretty nice, and my room had a window full of trees, which I didn’t expect from a city:

We stayed two to an apartment, each with our own bedroom. After a full day of sessions and group work, my room was the one place I could close the door, call home and switch off for a bit. It also doubled as a workspace on the nights the project didn’t finish at the office.

My roommate was a grad from Stellies, and we ended up helping each other out with pretty much everything, from project bugs to figuring out what to cook.

Joburg itself took some getting used to. The first thunderstorm was insane. The rain up there is on another level compared to Cape Town, and it shows up out of nowhere. The people made up for it though. Everyone I met was so much friendlier and less cliquey than I’m used to.

Melrose Arch ended up being where we spent most evenings. It’s walkable, there’s food everywhere, and the square looks completely different at night:

walking through Melrose Arch Melrose Arch in the morning Melrose Arch square at night

Entelect HQ

I’d actually been to the Joburg office once before. In May 2025 I came up for my interview. Walking back in a year later as a software engineer, and not a nervous candidate, was a pretty cool moment:

the office building from below me in the office elevator

The office is calm and modern, with long corridors and glass meeting rooms. It looks like the offices in those “day in the life of a software engineer” videos, except this time I was the one working there. There are plenty of hot desks with monitors, so you can sit wherever you want, and the meeting rooms have proper conferencing setups:

Entelect Johannesburg office sign corridor

The coffee at HQ is really good, so I had a lot of it. On Wednesdays there are croissants too, and they go with Entelect Engage, which is like an in-house podcast hosted by different Entelectuals:

coffee at the window Wednesday croissant

Engage is a cool part of the week. You grab a croissant, sit down, and listen to someone talk about what they work on. As a new person, it’s a quick way to find out who does what, and who to ask when you get stuck later.

Growth isn’t optional, but sleep definitely was

Ok, let’s talk about the actual work. The day after the welcome we were split into groups, and each group worked on one project for the full eight weeks. Eight weeks is long enough that you stop treating it like an assignment. You make design decisions, you live with them, and you rewrite the parts that turn out wrong.

In my post on studying CS in the age of AI I wrote that universities still teach recall when they should be teaching how to build. The bootcamp was eight weeks of building.

My group was super cool. After the first few weeks we found our rhythm and became very good at multitasking and coordinating demos. One demo we only planned the morning of, and we absolutely nailed it:

my group in a meeting room

Most days we’d book one of the meeting rooms, put the Jira board up on the TV and work through it together. With a door and a screen, we could argue about a design out loud without bothering anyone, then split up and build.

Nobody could hold the whole project in their head, so we leaned on each other a lot. Sometimes that wasn’t enough, and the team you lean on gets bigger. At one point we were properly stuck setting up an ORM in Java, so we pulled in one of the seniors. They came back with a really cool fix, and a much simpler way of thinking about the problem. We’d been designing the tables first and then fighting to make our Java classes fit them. The senior told us to flip it: design the objects your code actually wants to work with, and let the ORM worry about turning them into rows. Think of it as a document store that happens to sit on top of SQL. Once we looked at it that way, the mapping mostly wrote itself:

a senior helping my group with our ORM setup

Instead of starting from a customer table and an address table with a foreign key between them, you start from the object you’d want to pass around in your code, a customer that holds its own addresses:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
@Entity
public class Customer {
    @Id @GeneratedValue
    private Long id;

    private String name;

    @OneToMany(mappedBy = "customer", cascade = CascadeType.ALL)
    private List<Address> addresses = new ArrayList<>();
}

From there it does feel like saving a document. customerRepository.save(customer) writes the customer and every address in one call, and the ORM works out the tables, the foreign key and the inserts.

On the left, the code holds one Customer object with an id, a name and two Address objects inside it, and calls customerRepository.save(customer). In the middle, the ORM reads the entity mapping, inserts the customer, sets customer_id on each address and inserts both addresses. On the right, the database ends up with a customer table holding one row and an address table holding two rows, each pointing back to the customer through a customer_id foreign key.Your codeThe ORMThe databaseCustomerid: 1name: SamaddressesAddress · 12 Main RdAddress · 4 Oak Averepository.save(customer)Read the @Entity mappingINSERT customergets id 1Set customer_id = 1on each addressINSERT 2 addressescustomerid · name1 · Samaddressid · customer_id · street1 · 1 · 12 Main Rd2 · 1 · 4 Oak AveFK

Every day, senior Entelectuals came in to teach and mentor us. They do this work for real clients, so the sessions were about how they actually approach problems, and afterwards they’d look at what we were building.

On top of that, our group had a weekly mentor session with a senior Entelectual. Our mentor Sheldon once told me to step back and look at the bigger picture from the client’s point of view. They’re the person who just wants their life made easier, and a lot of the time the thing that makes it easier is the simpler solution. That has stuck with me since.

The seniors also kept pushing us to ask questions, especially the ones that feel too basic to ask out loud. It’s tempting to save those for a quiet Google search later, but someone else in the room is usually wondering the same thing. The seniors treated a basic question with the same care as a hard one.

You learn one thing fast: Entelectuals love saying “it depends”. Should we use this pattern? It depends. Is this the right database? It depends. By week two we were saying it too:

"what if I-" "it depends" meme

It sounds like a dodge, but it’s the most honest answer in software. After a few weeks I stopped being annoyed by it and started asking the follow-up question: depends on what? That’s usually where the useful part of the answer is.

The sessions weren’t all lectures either. There were Kahoots to check whether we’d actually been paying attention, and they got competitive very quickly. When the day ended, the work didn’t always stop. A few of us would carry on over Discord, trying to get one more thing working before calling it.

kahoot laptop open late at night errors

And there were a lot of errors. Spring stack traces in particular, which are long enough that the actual problem is usually buried somewhere around line 4300:1

a Spring IllegalStateException stack trace

The biggest habit I picked up was to sit down and properly understand the problem before touching a solution. It’s tempting to jump straight into code, but once you understand why something needs to exist, the how comes a lot easier.

On the nights the work carried on at home, my desk by the window and the balcony became a second office, fuelled by whatever was left in the cupboard:

Cooking for yourself every night is its own bootcamp. I got very good at gourmetifying noodles.

The best part

This was the best part. There were 75 of us from universities across South Africa. We were split into different groups for the project, but everyone became close anyway. The Cape Town squad especially, although we adopted a few Joburgers along the way.

the gang

Most of us were in the same position: new city, no friends there yet, and eight weeks to fill outside of work. That makes it very easy to say yes to plans. Someone would suggest dinner in the group chat, and by the end of the night half the cohort would be at the table.

We also had a meme channel on Discord, and at one point the seniors set us a challenge to come up with the best meme. I sometimes think we took that challenge more seriously than our project.

Then there were the games nights, and there were tons of them. Not video games, but actual in-person games like Imposter, where everyone gets the same secret word except one person, who has to bluff their way through the clues without getting caught.

Outside the office we did team dinners, a trip to Gold Reef City2 and a lot of general goofing around.

The smaller things stuck with me just as much as the outings: long dinners where nobody wanted to leave, and outings that started as a “quick walk to Melrose” and ended hours later.

At the end of February we packed up and flew home. Leaving was weirder than arriving, because by then Joburg had a routine and the same group of people every day. At least the Cape Town crew got to fly back together:

lobby with luggage flight home

The lessons learnt

It wasn’t all dinners and games. Bootcamp was hard, and there were plenty of tears along the way from how difficult it got. 10/10, I loved the challenge.

The final demo was hectic, and like every demo before it, it came with a lot of constructive feedback. I wouldn’t change it for the world though. Our seniors go to insane lengths to prepare us for the real world, and you can feel it by the end.

If I had to boil the eight weeks down to three lessons I’m taking with me into client work, they’d be these:

  1. Ask, ask, ask. Everyone around you is figuring things out too, and whatever you’re stuck on, someone has probably hit it before. So ask, and ask the questions that feel too basic. Most people are happy to share what they know, but they can’t help if you don’t ask.
  2. Make mistakes, then learn from every one. I made a lot of them, and bootcamp was the cheapest place I’ll ever get to be wrong. The habit worth keeping is working out why something broke before moving on, because the same mistake costs a lot more once real users are involved.
  3. Take the feedback, then go ask for more. Every demo came back with notes, and the only useful thing to do with them is fix what they point at. I don’t wait for the next demo anymore. Ask someone to look at your work while it’s still easy to change.

Growth isn’t optional. Sleep was, but growth wasn’t.

There’s no offer at the end like with a software engineering internship, because we were full-time employees from day one. The bootcamp is there to get you ready for client work. Most of us were placed at clients straight after. Some others in our cohort spent a bit of time on TFO3 (the bench) first, upskilling for their placements.

If you’re in the next cohort: use bootcamp as a sandbox and break things, and say yes to the outings. The dinners are where the cohort turns into friends.

If you want to apply, start at the Entelect graduate programme page. Or reach out to me if you want a referral or a coffee chat.

Thanks to Entelect for looking after us for eight weeks, to Ahmed and Sas for running the bootcamp, to all the bootcamp presenters and the senior Entelectuals who gave up time every day to teach and mentor us, and to my group for being super cool.


  1. Spring didn’t want us opening a transaction by hand on its shared EntityManager. It wants to manage transactions itself through @Transactional, so it throws an IllegalStateException the moment you try. The fix was one annotation. Finding it took an afternoon. ↩︎

  2. We went the day before our first big demo. ↩︎

  3. TFO stands for The First Order. ↩︎