A couple people had some great comments that should get you started; I'd just like to add that you don't need to do everything at once either and your workflow can be flexible. When I'm making a board with weird parts, I like to first just go into the symbol editor, make a new project library, and draw out whatever I need for my project with the correct pin assignments. Then at least you can focus on copying the schematic over and getting the ball rolling.

Once you are happy with the schematic, and parts are roughly placed where you want them on the board, you can go ahead and jump into the footprint editor, make a project library in there with the same name, and draw the physical copper layout for your tubes or whatever else to attach to based on datasheets or caliper measurements. Then you run footprint assignment to match up all the symbols with their corresponding footprint, and update the PCB to populate it with parts to lay out. Once the parts are placed logically where routing will be sane, follow the ratsnest connection lines to get your board routed.

Last you want to go to your manufacturer's website, look up all their specifications on board construction [0], and make sure all their recommended design rules and board stackup are plugged into board setup. This may mean going back and changing some trace sizes, trace placements, vias, and so on to pass design checks. Later you will do this earlier, but it's better not to get bogged down at first and just start designing, and you'll learn why things are routed as they are.

After this, spend time inspecting your board, looking for errors, making sure all checks pass and everything makes sense after a few reviews. Then export your gerbers and drill maps and send the zip to your manufacturer.

It's a little daunting at first because there are just a lot of steps between a schematic -- essentially a cartoon version of what your circuit will be, and a layout -- what your circuit will actually look like. You don't have to do every step at once and once you have the schematic drawn, you can just keep adding to it until you have something that works.

[0] https://docs.oshpark.com/design-tools/kicad/kicad-design-rul...

Each of the steps I outlined above, #1, #2, #3 and #4, are a new set of keyboard buttons and GUIs to learn for KiCad.

Yes, it's a lot to take at once. But fortunately, you only have to move forward one step at a time.

--------

Maybe starting at #2, Schematic, would be the only 'out of order' thing I'd recommend. There might be enough library parts to fill out a large section of your schematic (or maybe not...).

Inevitably, you will have to tackle #1 (symbol editor) and #3 (footprint editor) before you finish #2 and start step #4.

---------

I agree it's a lot to take in at once. But after you do all four steps and understand them, there is a sense of order and process. Especially as #1 (setting the pinout on a symbol), #2 (saying what pins are connected) and #3 (saying which pins belong where physically) are all accomplishing computerized checks to make #4 less error prone.

It's a lot of info to tell KiCad, and any other PCB editor will need all this information as well, so none of it was wasted effort.

It's just a lot of up front complexity that really is intimidating.

---------

#2 schematic editor might be a good starting point because it's what you expect to do. #1 and #3 are somewhat unintuitive steps.

In addition to the other recommendations in the thread, it may be useful to learn how the whole process works (KiCad, ordering or making PCBs, and assembling everything) with an even simpler circuit with just a few components. Making a simple battery + LED + resistor + switch circuit would involve learning almost the same amount about KiCad etc. as a more complicated circuit (within reason), with a lot less opportunity to be overwhelmed by component selection, PCB layout, etc. It would also be fairly cheap to make mistakes, since the PCB could be quite small and would probably cost only a few dollars even from a fairly high-end PCB manufacturer (I like OSH Park, but they can be expensive for large boards; see pcbshopper.com for price comparison).

I think you can just use CONN_01X00 pin header parts to represent tubes on the circuit schematics, then define just the footprint for the tube, either from its datasheet or ANSI/ISO/DIN/GOST connector specification. Then that footprint can be assigned to corresponding J0 on the imported PCB file. You can also print the PCB to visually test fitment. That might not be the correctest way but nor should be the wrongest approach.

One of the most confusing things when I started using KiCad is its two main features, EESchema and PCBnew, are basically two independent open source projects. So they're not tightly coupled, but works by importing and exporting files and manually assigning items in one side to the other.

For me it helps a lot to get some one-on-one to get me rolling.

Consider findig a makerspace nearby and see if they have some courses or people willing to help. There's one in my town and they have an active slack and weekly "maker evenings" where it's easy to get help.

Alternatively find some online communities where you can get some help.

As an example, this[1] YouTube channel has some great videos on layout and more with KiCad, as well as a very nice Discord community with newbies and professionals. I'm sure there are others, but that's where I got some great help when I got my feet wet.

[1]: https://www.youtube.com/c/MicroTypeEngineering

Can you share the schematic? I'm not familiar with KiCad or other similar software, so take this with a grain of salt, anyway I think that for simple schematics, especially that old, meaning all tht parts, single side pcbs, unless one is recreating a complex circuit, probably the "by hand" approach is a lot faster than using software.

This original article is a pretty complete reference for everything you need.

Consider keeping it open as you try to achieve your recreation.

Or read a section first (e.g. how to create a footprint or symbol) to better understand what is happening and then watch a tutorial video of someone doing exactly that to see it in action.

Start by building a prototype proof of concept on a breadboard or prototyping board!