`lzma` compresses the most and `zlib` is about as fast as `zstd` in `django_redis` as compressor.

20 Jul 2026 1:01am GMT

I'm Claude Certified Architect - Foundations now. Look at me.

A friend from work, Daniel, pinged me right after he started studying because he was confused and a little frustrated. He'd gone through the official docs, done a couple of practice exams, and felt like there was no connection between what he was studying and what the exam was actually testing. Fair. I felt the same way when I started. So we hopped on a call, I dumped everything I knew, and this post is basically that call cleaned up so more people can use it.

Fair warning up front: this is part study guide, part honest review. I'll tell you how to pass, but I'm also going to be honest about the parts that felt like studying for the exam rather than becoming a better engineer. Both things are true at once.

What I studied with

The exam I took is the Claude Certified Architect - Foundations. The single most useful resource for me was the Claude Certification Guide. The lessons are very good, and everything that showed up on my exam was covered by the syllabus there. I took notes like a maniac: more than half of a physical notebook, front and back, is just Claude notes from that site. I still recommend it without hesitation, because I genuinely learned a lot from it, not just enough to pass.

The thing I liked most about it is that it teaches you to recognize the pitfalls the exam throws at you, without spoon-feeding you exactly what they are. So instead of memorizing "the answer is X," you build the instinct to spot what's going on. I prefer that. It stuck better.

One warning: don't over-index on practice exams. I did five or ten before the real thing, and the free mock exams floating around out there are way too basic compared to what you'll actually face. The guide's questions are the closest I found, and even those I wouldn't call identical to the real exam. Daniel was studying with a different mock exam site and the questions were so convoluted and samey that he said he fell asleep halfway through. So calibrate your expectations: use the mocks to get familiar with the format, not to predict the exact questions.

Study Claude CLI. Seriously. Study it.

This was the hardest part of the exam by far, and the part I was least prepared for.

I genuinely did not think they were going to ask about specific flags. The Claude CLI has something like a thousand of them, and my attitude going in was "I'm not learning all of this, if I need a flag I'll just run claude --help." In the real world, that's exactly what you do. Why would you memorize flags you can look up in two seconds? Daniel made this same point on our call, and honestly I agree with him.

But the exam doesn't care about that argument. They started asking about specific flags and what they do, and I sat there thinking I messed up.

So here's my advice: study the flags. You don't need to memorize all thousand of them, but go through the ones on the certification course and at least read each one and understand what it means. Not just claude -p. All of them. If you do one thing differently from how I studied, make it this.

Read the questions. Then read them again.

The exam is 60 questions, and you get 2 and a half hours. That's more than enough time. I finished the whole thing in about an hour and a half, went back through everything, and still submitted with time to spare. So don't rush.

But do read carefully, because the questions are convoluted. Sometimes it feels like they're testing whether you can read a wall of text, parse it, and pick the best answer, more than whether you know the material. English isn't my first language, and after about 45 minutes of dense, twisty questions I was toast. Budget your brain, not just your time.

A few tactics that worked for me:

• Read the full question before you even look at the answers. Give it 30 to 45 seconds. If it's obviously straightforward, great, move on. If it's not, you'll be glad you understood the setup before the answers tried to trick you.
• Don't get stuck. If you've spent two or three minutes on one question, pick something, flag it, and move on. You can always come back.
• Use the "flag for review" feature. Before you submit, the exam shows you a list of everything you answered plus everything you flagged. I went back through all my flagged ones, re-read them, and changed a couple of answers. Then, with 30 minutes left, I went through the entire exam one more time reading each prompt and my answer. Was that overkill? Probably. Did it work? Also yes. I'm thorough like that.

The "pick the most correct answer" trap

This is the thing that trips everyone up, so it gets its own section.

A lot of questions have two answers that both technically work. The exam wants you to pick the one that's most correct, and "most correct" almost always means "the most Claude-native way of doing it."

Concrete example from the kind of question you'll see: you've got a process that runs sequentially and takes too long, and you need to cut the latency. One option is to implement a message queue to parallelize the slow tasks. Another is to spawn additional agents so the work gets split up. Both reduce latency. Both are reasonable. But Claude doesn't have a message queue, and the exam heavily favors two ideas: use Claude for everything, and let the agent take control. The parallel-agents answer wins because Claude decides how many agents to spawn, and if one fails it can respawn it. The queue answer works in real life, but it's not the answer the exam is looking for.

So when two answers both work, ask yourself: which one leans hardest into letting Claude do the thing? That's usually the "most correct" one.

The exam-day logistics nobody warns you about

The exam costs 125 USD, it's fully proctored, and the proctoring is strict. Here's what actually happens so you're not caught off guard:

• You install an app called OnVue on your machine. (I already uninstalled it. No shade, I just didn't need it hanging around.)
• Before the exam, you submit photos of your environment. Then a proctor called me to take additional photos. I waited around 10 minutes for the proctor to show up, so be patient.
• Follow the instructions to the letter. They are extremely strict. I had a random piece of paper sitting on my desk and they made me throw it away. Clear your whole desk before you check in.
• Be ready to join right at your "check-in" time so the proctor can get to you on schedule.

None of this is hard, it's just a lot of process, and it's easier when you know it's coming.

So… is it actually worth it?

Here's the honest part, because Daniel asked me this directly and I don't want to pretend.

Did I learn to take an exam, or did I learn something real? My honest answer is about 50/50. A chunk of the studying was pure exam-prep: memorizing flags I'd normally just look up, learning to spot which answer the test wants. That part I won't oversell.

But the other half genuinely changed how I work. I picked up new things while studying and actually changed parts of my workflow afterward. So it's not just a piece of paper. There's real signal in there if you go in wanting to learn and not just wanting to pass.

Would I tell you to get certified? If your company is paying, or you've got the time and 125 bucks to spare, yeah, go for it. You'll come out a bit sharper and you get a shiny badge for LinkedIn. Just go in with clear eyes about which parts are learning and which parts are hoop-jumping.

Good luck. If you're studying for this and you get stuck, my inbox is open.

See you in the next one!

19 Jul 2026 5:00am GMT

Migrating from FeinCMS to feincms3

FeinCMS is still actively maintained, but development, bugfixes and new features mostly land on feincms3 and django-content-editor these days, not on FeinCMS itself. That's reason enough to eventually move a project over.

Someone asked on the feincms3 issue tracker whether there's a guide for making that move. There isn't one yet, so I thought I'd expand on my comment in the issue tracker and post it here too in the hope that it's useful to others. The post is based on a gradual migration we did in a large, long-lived Django project - a textbook publishing platform with years of content. Unfortunately I can't show more details since it's a commercial, closed source project. During the migration, the platform stayed in production the whole time, aside from the inevitable bug here and there.

The most important insight is that FeinCMS 1 content types and feincms3 plugins are close enough that we could keep using the same underlying database tables. An export/import step isn't required at all.

The overall shape of the migration

• FeinCMS keeps managing the plugin tables as usual, for now.
• New feincms3 plugin models get added alongside the old ones, with managed = False in their Meta and db_table pointing at the exact table FeinCMS already created. Django doesn't think these are new or different tables, it just uses the ones that already exist.
• The admin gets migrated from ItemEditor to django-content-editor's ContentEditor. If your project has more than one independent hierarchy (in our case, one per book series instead of a single global page tree) you can migrate them independently instead of having to do it all in one step.
• Rendering moves over from FeinCMS's rendering machinery to feincms3's, again piece by piece: the HTML generation for the frontend, any full text search indexers, anything else that touches the content.

The examples below use Chapter and ChapterPlugin because that's the hierarchy in this particular project, one tree per book series rather than one global page tree. Most feincms3 projects center on a single Page model instead, so read Page wherever you see Chapter; the rest still applies.

Getting the migration state right

Here's a concrete proxy model from that migration, simplified. RichTextContent is our own abstract mixin, holding nothing but the actual text field, shared between the FeinCMS and feincms3 sides of the code base. The same role is played by feincms3.plugins.richtext.RichText if you use feincms3's bundled plugin instead of your own. ChapterPlugin in turn only wires up the boilerplate that's specific to being a plugin content type of our Chapter model:

class RichTextContent(models.Model):
    text = RichTextField()

    class Meta:
        abstract = True

class RichText(ChapterPlugin, RichTextContent):
    class Meta:
        db_table = "textbooks_chapter_richtextcontent"
        managed = False  # Proxy for the real model still owned by FeinCMS

The exact table name depends on how FeinCMS auto-generated it for your project (a mix of the app label, the base model and the content type name), so look it up rather than guessing. ./manage.py sqlmigrate or just inspecting the database will tell you.

For the very last step, once a plugin has been converted and managed = False can go away, use Django's migrations.SeparateDatabaseAndState. It lets you change the migration state without touching the database at all. That's exactly what you need here since the table already exists and already has the right shape; only Django's idea of what the schema is needs to catch up.

You don't even have to write these migrations by hand. Remove managed = False, run ./manage.py makemigrations as usual, and Django writes out the normal operations it would generate for any new model. The only manual step is moving that generated list of operations into the state_operations argument of a single SeparateDatabaseAndState operation, redacted and shortened here:

class Migration(migrations.Migration):
    dependencies = [
        ("textbooks", "0096_remove_richtextcontent_managed"),
    ]

    operations = [
        migrations.SeparateDatabaseAndState(
            state_operations=[
                migrations.CreateModel(
                    name="RichText",
                    fields=[
                        ("id", models.AutoField(primary_key=True, serialize=False)),
                        ("text", models.TextField()),
                        ("chapter", models.ForeignKey(to="textbooks.Chapter", ...)),
                    ],
                    options={"db_table": "textbooks_chapter_richtextcontent"},
                ),
            ],
            # No database_operations -- the table is already exactly like this.
        ),
    ]

As always, test this on a copy of the database first and make sure you have backups. Hand-editing migrations isn't generally recommended, but it's safe if you know exactly what you're doing. Treat it with the same care as any other schema change.

The page tree: mptt vs. tree-queries

FeinCMS 1's bundled Page model uses django-mptt for the page hierarchy, while feincms3's page comes with django-tree-queries instead. If you're using FeinCMS's own Page model and migrating to feincms3's, this can be a little bit painful since the database schema is different. There's a dedicated guide for migrating from django-mptt in the django-tree-queries documentation.

Once the last plugin has switched over, FeinCMS can be dropped from the project entirely, including from the requirements. The models end up exactly where they would have been if you'd started the project with feincms3 in the first place - and you never had to export or import a single row to get there.

18 Jul 2026 5:00pm GMT